rc 0.2.0 → 0.3.0

data/demo/01_config.md

@@ -0,0 +1,14 @@
+# Config Class
+
+The Config class encapsulates a single config entry. Every Config instance has a `command`, `feature`,
+and `profile` atribute, as well as a procedure.
+
+    config = RC::Config.new('foo', :profile=>'bar') do
+      'example'
+    end
+
+    config.command       #=> 'foo'
+    config.feature       #=> 'foo'
+    config.profile       #=> 'bar'
+    config.to_proc.call  #=> 'example'
+

data/demo/02_configuration.md

@@ -0,0 +1,51 @@
+# Configuration
+
+The Configuration class handle evaluation of a project configuration file.
+
+    rc = RC::Configuration.new
+
+We can use the `#instance_eval` method to evaluate a configuration for our
+demonstration.
+
+    rc.evaluate(<<-HERE)
+      config :sample1 do
+        "block code"
+      end
+    HERE
+
+Evaluation of a configuration file, populate the Confection.config instance.
+
+    sample = rc.configurations.last
+    sample.command  #=> 'sample1'
+    sample.profile  #=> 'default'
+    sample.class    #=> RC::Config
+
+A profile can be used as a means fo defining multiple configurations
+for a single tool. This can be done by setting the second argument to
+a Symbol.
+
+    rc.evaluate(<<-HERE)
+      config :sample2, :profile=>'opt1' do
+        "block code"
+      end
+    HERE
+
+    sample = rc.configurations.last
+    sample.command  #=> 'sample2'
+    sample.profile  #=> 'opt1'
+
+Or it can be done by using a `profile` block.
+
+    rc.evaluate(<<-HERE)
+      profile :opt1 do
+        config :sample2 do
+          "block code"
+        end
+      end
+    HERE
+
+    sample = rc.configurations.last
+    sample.command  #=> 'sample2'
+    sample.profile  #=> 'opt1'
+
+

data/demo/03_import.md

@@ -0,0 +1,48 @@
+# Importing
+ 
+## Configuration Importing
+
+Configurations can be imported from another project using the `:from` option.
+
+    rc = RC::Configuration.new
+
+    rc.config :qed, :profile=>'example', :from=>'test'
+
+    rc.to_a.size.assert == 1
+
+The configuration can also be imported from a different profile.
+
+    rc.config :qed, :profile=>:coverage, :from=>['test', :profile=>'simplecov']
+
+    rc.to_a.size.assert == 2
+
+Although it will very rarely be of use, it may also be imported from another
+feature or command too.
+
+    rc.config :example, :from=>['test', :command=>'sample']
+
+Imported configurations can also be augmented via a block.
+
+    rc = RC::Configuration.new
+
+    rc.config :qed, :from=>['test', :profile=>'simplecov'] do
+      # additional code here
+    end
+
+    rc.to_a.size.assert == 2
+
+Technically this last form just creates two configurations for the same
+tool and profile, but the ultimate effect is the same.
+
+## Script Importing
+
+Library files can be imported directly into configuration blocks via the
+`#import` method.
+
+    rc.config :example do
+      import "fruitbasket/example.rb"
+    end
+
+This looks up the file via the `finder` gem and then evals it in the context
+of the config block.
+

data/demo/06_interface.md

@@ -0,0 +1,39 @@
+# Interface
+
+The main means of workin with RC's API are the RC class methods,
+collectively called the Inteface.
+
+Let's say we have a configuration file `.ruby` containing:
+
+    config :example do
+      "example config"
+    end
+
+    config :example, :profile=>:something do
+      "example config using profile"
+    end
+
+To get the configuration of the current project --relative to the 
+current working directory, use the `configuration` method.
+
+    RC.configuration
+
+The configuration properties of the current project can be
+had via the `properties` method.
+
+    RC.properties
+
+The profile names can be looked up for any given tool via the `profile_names`
+method.
+
+    RC.profile_names(:example)  #=> ['default', 'something']
+
+The number of feature configurations in the current project can be
+had via the `size` method.
+
+    RC.configuration.size  #=> 1
+
+A list of all configuration entries can be had by calling #to_a.
+
+    RC.configuration.to_a.size  #=> 2
+

data/demo/applique/ae.rb

@@ -0,0 +1 @@
+require 'ae'

data/demo/applique/file.rb

@@ -0,0 +1,8 @@
+require 'rc/api'
+
+When 'configuration file `(((\S+)))` containing' do |slots, text|
+  RC.clear! #configurations.clear
+  fname = [slots].flatten.first  # temporary transition to new QED
+  File.open(fname, 'w'){ |f| f << text }
+end
+

data/demo/applique/fixture.rb

@@ -0,0 +1,10 @@
+# Setup the fixtures.
+
+dir = File.dirname(__FILE__) + '/fixture'
+Dir.entries(dir).each do |file|
+  next if file == '.' or file == '..'
+  path = File.join(dir, file)
+  next if File.directory?(path)
+  FileUtils.install(path, Dir.pwd)
+end
+

data/demo/applique/fixture/.ruby

@@ -0,0 +1,11 @@
+# exmaple configuration file
+
+config :example do
+  "example config"
+end
+
+config :example, :profile=>:data do |ex|
+  ex.name = 'Tommy'
+  ex.age  = 42
+end
+

data/demo/cov.rb

@@ -0,0 +1,7 @@
+# Usage: qed -r ./spec/cov
+require 'simplecov'
+SimpleCov.start do
+  coverage_dir 'log/coverage'
+  #add_group "Label", "lib/qed/directory"
+end
+

data/lib/c.rb

@@ -0,0 +1,8 @@
+# This script is for use in the RUBYOPT, e.g. RUBYOPT="-rc".
+#
+# My apologies to the author of the `c` gem. If it helps,
+# I think it would be better if the functionaility of the
+# `c` gem were provided via other gems, e.g. the `github`
+# gem.
+
+require 'rc'

data/lib/rc.rb

@@ -0,0 +1,10 @@
+# RC - Runtime Configuration
+# Copyright (c) 2011 Rubyworks
+
+# Runtime Configuration for Ruby.
+#
+module RC
+  require 'rc/api'
+  autoconfigure
+end
+

data/lib/rc/api.rb

@@ -0,0 +1,4 @@
+# This file is simply a shortcut to `interface.rb`.
+
+require 'rc/interface'
+

data/lib/rc/config.rb

@@ -0,0 +1,305 @@
+module RC
+
+  # Config encapsulates a single configuration entry as defined in a project's
+  # ruby rc file. A config consists of a possible `command`, `feature`,
+  # `profile` and `onload` flag.
+  #
+  # If `command` or `feature` are nil, then the configuration applies to all
+  # commands and/or features.
+  #
+  # If profile is `nil` it automatically becomes `default`, which is the 
+  # profile used when no profile is specified.
+  #
+  class Config
+
+    #
+    # Initialize Config instance. Config instances are per-configuration,
+    # which means they are associated with one and only one config entry.
+    #
+    # @param [#to_s] target 
+    #   The command or feature name. (optional)
+    #
+    # @param [Hash] properties
+    #   Any additional properties associated with the config entry.
+    #
+    def initialize(*args, &block)
+      properties = (Hash === args.last ? args.pop : {})
+      target     = args.first
+
+      @property = {:command=>nil, :feature=>nil, :profile=>'default'}
+
+      if target
+        @property[:command] = target.to_s
+        @property[:feature] = target.to_s
+      end
+
+      @block = block
+
+      properties.each do |k, v|
+        property(k,v)
+      end
+    end
+
+    #
+    # Get/set property.
+    #
+    def property(name, value=ArgumentError)
+      if value == ArgumentError
+        get(name)
+      else
+        set(name, value)
+      end
+    end
+
+    #
+    # The feature being configured.
+    #
+    def feature
+      @property[:feature]
+    end
+
+    #
+    # The name of command being configured.
+    #
+    def command
+      @property[:command]
+    end
+
+    # @todo Deprecate #tool alias?
+    alias :tool :command
+
+    #
+    # The name of the profile to which this configuration belongs.
+    #
+    def profile
+      @property[:profile]
+    end
+
+    #
+    # The library from which this configuration derives.
+    #
+    def from
+      @property[:from]
+    end
+
+    #
+    #
+    #
+    def onload?
+      @property[:onload]
+    end
+
+    #
+    # Most configurations are scripted. In those cases the 
+    # `@block` attributes holds the Proc instance, otherwise
+    # it is `nil`.
+    #
+    attr :block
+
+    #
+    # IDEA: Presets would be processed first and not require the underlying feature.
+    #
+    #def preset?
+    #  @property[:preset]
+    #end
+
+    #
+    # The arity of the configuration procedure.
+    #
+    # @return [Fixnum] number of arguments
+    #
+    def arity
+      @block ? @block.arity : 0
+    end
+
+    #
+    # Require the feature.
+    #
+    def require_feature
+      begin
+        require feature
+      rescue LoadError
+        #warn "No such feature -- `#{feature}'"
+      end
+    end
+
+    #
+    # Call the configuration procedure.
+    #
+    def call(*args)
+      block.call(*args) if block
+    end
+
+    #
+    # Returns underlying block.
+    #
+    def to_proc
+      block
+    end
+
+    ##
+    ## Convert block into a Hash.
+    ##
+    ## @return [Hash]
+    ##
+    #def to_h
+    #  HashBuilder.new(&self).to_h
+    #end
+
+    #
+    # Copy the configuration with alterations.
+    #
+    # @param [Hash] alt
+    #   Alternate values for configuration attributes.
+    #
+    # @return [Config] copied config
+    #
+    def copy(alt={})
+      tool = @property[:feature] || @property[:command]
+      copy = self.class.new(tool, @property.dup, &@block)
+      alt.each do |k,v|
+        copy.property(k, v)
+      end
+      copy
+    end
+
+    #
+    # Match config against tool and/or profile names.
+    #
+    # @return [Boolean]
+    #
+    def match?(*args)
+      props = Hash === args.last ? args.pop : {}
+
+      if target = args.shift
+        props[:command] = target.to_s
+        props[:feature] = target.to_s
+      end
+
+      if props[:profile]
+        props[:profile] = (props[:profile] || :default).to_s
+      end
+
+      props.each do |k,v|
+        pv = property(k)
+        return false unless (pv.nil? || pv == v)
+      end
+
+      return true
+    end
+
+    #
+    # Does the given `feature` match the config's feature?
+    #
+    # @return [Boolean]
+    #
+    def feature?(feature=RC.current_feature)
+      return true if self.feature.nil?
+      self.feature == feature.to_s
+    end
+
+    #
+    # Does the given `command` match the config's command?
+    #
+    # @return [Boolean]
+    #
+    def command?(command=RC.current_command)
+      return true if self.command.nil?
+      self.command == command.to_s
+    end
+    alias_method :tool, :command?
+
+    #
+    # Does the given `profile` match the config's profile?
+    #
+    # @return [Boolean]
+    #
+    def profile?(profile=RC.current_profile)
+      self.profile == (profile || 'default').to_s
+    end
+
+    #
+    # @todo The feature argument might not be needed.
+    #
+    #def configure(feature)
+    #  return false if self.feature != feature 
+    #
+    #  if setup = RC.setup(feature)
+    #    setup.call(self)
+    #  else
+    #    block.call if command?
+    #  end
+    #end
+
+    ##
+    ## Ruby 1.9 defines #inspect as #to_s, ugh.
+    ##
+    #def inspect
+    #  "#<#{self.class.name}:#{object_id} @tool=%s @profile=%s>" % [tool.inspect, profile.inspect]
+    #end
+
+    #
+    # Does the configuration apply?
+    #
+    # @return [Boolean]
+    #
+    def apply_to_command?
+      return false if onload?
+      return false unless command? if command
+      return false unless profile? if profile
+      return true
+    end
+    alias_method :apply_to_tool?, :apply_to_command?
+
+    def apply_to_feature?
+      return false unless onload?
+      return false unless command? if command
+      return false unless profile? if profile
+      return true
+    end
+
+  private
+
+    #
+    # Get property.
+    #
+    def get(name)
+      @property[name.to_sym]
+    end
+
+    #
+    # Set property.
+    #
+    def set(name, value)
+      case name.to_sym
+      when :command
+        self.command = value
+      when :tool  # deprecate ?
+        self.command = value
+      when :feature
+        self.feature = value
+      when :profile
+        self.profile = value
+      else
+        @property[name.to_sym] = value
+      end
+    end
+
+    #
+    def command=(name)
+      @property[:command] = name ? name.to_s : nil
+    end
+
+    #
+    def feature=(path)
+      @property[:feature] = path ? path.to_s : nil
+    end
+
+    #
+    def profile=(name)
+      @property[:profile] = name ? name.to_s : 'default'
+    end
+
+  end
+
+end