tap 0.11.1 → 0.12.0

data/lib/tap/support/configuration.rb

@@ -1,170 +0,0 @@
-module Tap
-  module Support
-    
-    # Represents a configuration declared by a Configurable class.
-    class Configuration
-      class << self
-        
-        # Matches a short option
-        SHORT_OPTION = /^-[A-z]$/
-        
-        # Turns the input string into a short-format option.  Raises
-        # an error if the option does not match SHORT_REGEXP.
-        #
-        #   Configuration.shortify("-o")   # => '-o'
-        #   Configuration.shortify(:o)     # => '-o'
-        #
-        def shortify(str)
-          str = str.to_s
-          str = "-#{str}" unless str[0] == ?-
-          raise "invalid short option: #{str}" unless str =~ SHORT_OPTION
-          str
-        end
-        
-        # Matches a long option
-        LONG_OPTION = /^--(\[no-\])?([A-z][\w-]*)$/
-        
-        # Turns the input string into a long-format option.  Raises
-        # an error if the option does not match LONG_REGEXP.
-        #
-        #   Configuration.longify("--opt")                     # => '--opt'
-        #   Configuration.longify(:opt)                        # => '--opt'
-        #   Configuration.longify(:opt, true)                  # => '--[no-]opt'
-        #   Configuration.longify(:opt_ion)                    # => '--opt-ion'
-        #   Configuration.longify(:opt_ion, false, false)      # => '--opt_ion'
-        #
-        def longify(str, switch_notation=false, hyphenize=true)
-          str = str.to_s
-          str = "--#{str}" unless str.index("--")
-          str.gsub!(/_/, '-') if hyphenize
-          
-          raise "invalid long option: #{str}" unless str =~ LONG_OPTION
-          
-          if switch_notation && $1.nil?
-            str = "--[no-]#{$2}"
-          end
-
-          str
-        end
-      end
-      
-      # The name of the configuration
-      attr_reader :name
-      
-      # The reader method, by default name
-      attr_reader :reader
-      
-      # The writer method, by default name=
-      attr_reader :writer
-      
-      # True if the default value may be duplicated
-      attr_reader :duplicable
-      
-      # An array of optional metadata for self
-      attr_reader :attributes
-      
-      # Initializes a new Configuration with the specified name and default
-      # value.  Options may specify an alternate reader/writer; any
-      # additional options are set as attributes.
-      def initialize(name, default=nil, options={})
-        @name = name
-        self.default = default
-        
-        self.reader = options.has_key?(:reader) ? options.delete(:reader) : name
-        self.writer = options.has_key?(:writer) ? options.delete(:writer) : "#{name}="
-        @attributes = options
-      end
-
-      # Sets the default value for self and determines if the
-      # default is duplicable.  Non-duplicable values include
-      # nil, true, false, Symbol, Numeric, and any object that
-      # does not respond to dup.
-      def default=(value)
-        @duplicable = case value
-        when nil, true, false, Symbol, Numeric, Method then false
-        else value.respond_to?(:dup)
-        end
-        
-        @default = value.freeze
-      end
-      
-      # Returns the default value, or a duplicate of the default
-      # value if specified and the default value is duplicable.
-      def default(duplicate=true)
-        duplicate && duplicable ? @default.dup : @default
-      end
-      
-      # Sets the reader for self.  The reader is symbolized,
-      # but may also be set to nil.
-      def reader=(value)
-        @reader = value == nil ? value : value.to_sym
-      end
-      
-      # Sets the writer for self.  The writer is symbolized,
-      # but may also be set to nil.
-      def writer=(value)
-        @writer = value == nil ? value : value.to_sym
-      end
-      
-      # The argument name for self: either attributes[:arg_name]
-      # or name.to_s.upcase
-      def arg_name
-        attributes[:arg_name] || name.to_s.upcase
-      end
-      
-      # The argument type for self: either attributes[:arg_type]
-       # or :mandatory
-      def arg_type
-        attributes[:arg_type] || :mandatory
-      end
-      
-      # The long version of name.
-      def long(switch_notation=false, hyphenize=true)
-        Configuration.longify(attributes[:long] || name.to_s, switch_notation, hyphenize)
-      end
-      
-      # The short version of name.
-      def short
-        attributes[:short] ? Configuration.shortify(attributes[:short]) : nil
-      end
-      
-      # The description for self: attributes[:desc]
-      def desc
-        attributes[:desc]
-      end
-
-      # True if another is a kind of Configuration with the same name,
-      # default value, reader and writer; other attributes are NOT 
-      # taken into account.
-      def ==(another)
-        another.kind_of?(Configuration) && 
-        self.name == another.name &&
-        self.reader == another.reader &&
-        self.writer == another.writer &&
-        self.default(false) == another.default(false)
-      end
-      
-      # Returns self as an argv that can be used to register
-      # an option with OptionParser.
-      def to_optparse_argv
-        argtype = case arg_type
-        when :optional 
-          "#{long} [#{arg_name}]"
-        when :switch 
-          long(true)
-        when :flag
-          long
-        when :list
-          "#{long} a,b,c"
-        when :mandatory, nil
-          "#{long} #{arg_name}"
-        else
-          raise "unknown arg_type: #{arg_type}"
-        end
-
-        [short, argtype, desc].compact
-      end
-      
-    end
-  end
-end

data/lib/tap/support/gems/rake.rb

@@ -1,111 +0,0 @@
-require 'rake'
-require 'tap'
-
-module Tap
-  module Support
-    module Gems
-      class RakeManifest < Support::Manifest
-        def initialize(env)
-          @env = env
-          rake = ::Rake.application
-          super(rake.have_rakefile(env.root.root) ? [rake.instance_variable_get(:@rakefile)] : [])
-        end
-      end
-    
-      module Rake
-
-        def self.extended(base)
-          Tap::Env.instance_for(Dir.pwd).activate unless Tap::Env.instance
-          base.env = Tap::Env.instance
-        end
-      
-        attr_accessor :env
-       
-        def enq_top_level(app)
-          # takes the place of rake.top_level
-          if options.show_tasks
-            display_tasks_and_comments
-            exit
-          elsif options.show_prereqs
-            display_prerequisites
-            exit
-          else
-            top_level_tasks.each do |task_string|
-              name, args = parse_task_string(task_string)
-              task = self[name]
-              app.mq(task, :invoke, *args)
-            end
-          end  
-        end
-        
-        def collect_tasks(*args)
-          # a little song and dance for compliance with
-          # rake pre- and post-0.8.2
-          argv = args.empty? ? ARGV : args[0]
-          argv.collect! do |arg|
-            next(arg) unless arg =~ /^:([a-z_\d]+):(.*)$/
-            env_pattern = $1
-            rake_task = $2
-          
-            next(arg) unless entry = env.find(:envs, env_pattern, false)
-          
-            mini_path, env = entry
-            root_path = env.root.root
-          
-            if have_rakefile(root_path)
-              # load sequence echos that in raw_load_rakefile
-              puts "(in #{root_path})" unless options.silent
-              current_global_rakefile = $rakefile
-              $rakefile = @rakefile
-            
-              namespaces = Tap::Root.split(mini_path, false).delete_if do |segment| 
-                segment.empty?
-              end
-            
-              #if @rakefile != ''
-              eval nest_namespace(%Q{load "#{File.join(root_path, @rakefile)}"}, namespaces.dup)
-              #end
-            
-              $rakefile = current_global_rakefile
-              @rakefile = nil
-            
-              namespaces << rake_task
-              namespaces.join(":")
-            else
-              fail "No Rakefile found for '#{env_pattern}' (looking for: #{@rakefiles.join(', ')})"
-            end
-          end
-          
-          super
-        end
-      
-        def have_rakefile(dir=nil)
-          return super() if dir == nil
-          Tap::Root.chdir(dir) { super() }
-        end
-
-        protected
-      
-        NAMESPACE_STR = %Q{
-namespace(:'%s') do
-  %s
-end
-}.strip
-      
-        def nest_namespace(nest_str, namespaces)
-          return nest_str if namespaces.empty?
-        
-          NAMESPACE_STR % [
-            namespaces.shift, 
-            namespaces.empty? ? nest_str : nest_namespace(nest_str, namespaces)
-          ]
-        end
-      end
-    end
-  end
-end
-
-Rake.application.extend Tap::Support::Gems::Rake
-Tap::Env.manifest(:rakefiles) do |env|
-  Tap::Support::Gems::RakeManifest.new(env)
-end

data/lib/tap/support/instance_configuration.rb

@@ -1,173 +0,0 @@
-module Tap
-  module Support
-    
-    # InstanceConfiguration serves as a forwarding hash, where get and set operations
-    # for configurations are sent to instance methods rather than to an underlying data 
-    # store.  
-    #
-    #   class Sample
-    #     attr_accessor :key
-    #   end
-    #   sample = Sample.new
-    #
-    #   class_config = ClassConfiguration.new(Sample)
-    #   class_config.add(:key)
-    #
-    #   config = InstanceConfiguration.new(class_config)
-    #   config.bind(sample)
-    #
-    #   sample.key = 'value'
-    #   config[:key]                # => 'value'
-    #
-    #   config[:key] = 'another'
-    #   sample.key                  # => 'another'
-    #
-    # Non-config keys are simply stored:
-    #
-    #   config[:not_a_key] = 'value'
-    #   config[:not_a_key]          # => 'value'
-    #
-    #   config.store                # => {:not_a_key => 'value'}
-    #   config.to_hash              # => {:key => 'another', :not_a_key => 'value'}
-    #
-    class InstanceConfiguration
-      
-      # The bound receiver
-      attr_reader :receiver
-      
-      # The underlying data store for non-config keys
-      attr_reader :store
-      
-      # The ClassConfiguration specifying config keys
-      attr_reader :class_config
-      
-      def initialize(class_config, receiver=nil, store={})
-        @receiver = receiver
-        @store = store
-        @class_config = class_config
-      end
-      
-      # Updates self to ensure that each class_config key
-      # has a value in self; the config.default value is
-      # set if a value does not already exist.
-      #
-      # Returns self.
-      def update(class_config=self.class_config)
-        class_config.each_pair do |key, config|
-          self[key] ||= config.default
-        end
-        self
-      end
-      
-      # Binds self to the specified receiver.  Mapped keys are
-      # removed from store and sent to their writer method on 
-      # receiver.
-      def bind(receiver)
-        raise "already bound to: #{@receiver}" if bound?
-        raise ArgumentError, "receiver cannot be nil" if receiver == nil
-        
-        class_config.each_pair do |key, config|
-          receiver.send(config.writer, store.delete(key)) if config.writer
-        end
-        @receiver = receiver
-        
-        self
-      end
-      
-      # Returns true if self is bound to a receiver
-      def bound?
-        receiver != nil
-      end
-      
-      # Unbinds self from the specified receiver.  Mapped values
-      # are stored in store.  Returns the unbound receiver.
-      def unbind
-        class_config.each_pair do |key, config|
-          store[key] = receiver.send(config.reader) if config.reader
-        end
-        r = receiver
-        @receiver = nil
-        
-        r
-      end
-      
-      # Duplicates self, returning an unbound InstanceConfiguration.
-      def dup
-        duplicate = super()
-        duplicate.instance_variable_set(:@receiver, nil)
-        duplicate.instance_variable_set(:@store, @store.dup)
-        duplicate
-      end
-      
-      # Associates the value the key.  If bound? and the key
-      # is a class_config key, then the value will be forwarded
-      # to the config.writer method on the receiver.
-      def []=(key, value)
-        case 
-        when bound? && config = class_config.map[key.to_sym]
-          config.writer ? receiver.send(config.writer, value) : store[key] = value
-        else store[key] = value
-        end
-      end
-      
-      # Retrieves the value corresponding to the key. If bound? 
-      # and the key is a class_config key, then the value is
-      # obtained from the config.reader method on the receiver.
-      def [](key)
-        case 
-        when bound? && config = class_config.map[key.to_sym]
-          config.reader ? receiver.send(config.reader) : store[key]
-        else store[key]
-        end
-      end
-      
-      # True if the key is assigned in self.
-      def has_key?(key)
-        (bound? && class_config.key?(key)) || store.has_key?(key) 
-      end
-      
-      # Calls block once for each key-value pair stored in self.
-      def each_pair # :yields: key, value
-        class_config.each_pair do |key, config|
-          yield(key, receiver.send(config.reader)) if config.reader
-        end if bound?
-        
-        store.each_pair do |key, value|
-          yield(key, value)
-        end
-      end
-      
-      # Equal if the to_hash values of self and another are equal.
-      def ==(another)
-        another.respond_to?(:to_hash) && to_hash == another.to_hash
-      end
-      
-      # Returns self as a hash. 
-      def to_hash
-        hash = store.dup
-        class_config.keys.each do |key|
-          hash[key] = self[key]
-        end if bound?
-        hash
-      end
-      
-      def to_yaml(opts)
-        hash = {}
-        store.each_pair do |key, value|
-          hash[key.to_s] = value
-        end
-        
-        class_config.each_pair do |key, config|
-          hash[key.to_s] = bound? ? self[key] : config.default
-        end
-        
-        hash.to_yaml(opts)
-      end
-      
-      # Overrides default inspect to show the to_hash values.
-      def inspect
-        "#<#{self.class}:#{object_id} to_hash=#{to_hash.inspect}>"
-      end
-    end
-  end
-end