amp-pure 0.5.0

data/lib/amp/support/docs.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'yard'
+
+YARD::Registry.load
+
+module Docable
+  
+  def tag_callbacks; @tag_callbacks ||= {}; end
+  
+  def tag_callback(name, &block)
+    tag_callbacks[name] = block
+  end
+  
+  def docs_for(method)
+    klass = YARD::Registry.all(:class).detect do |k|
+      k.name == name.split("::").last.to_sym
+    end
+    
+    meth = klass.meths.detect {|m| m.name == method }
+    
+    puts "=== Documentation for #{self}##{method}"
+    puts meth.docstring
+    puts "---"
+    puts meth.signature
+    puts
+    
+    tag_callbacks.to_a.sort.each do |(tag, block)|
+      if meth.has_tag? tag
+        puts
+        tags = meth.tags.select {|t| t.tag_name == tag.to_s }
+        block.call meth, tags
+        puts
+      end
+    end
+    
+    puts "It can be found at #{meth.file}:#{meth.line}"
+    puts "==="
+  end
+end
+
+class Object
+  extend Docable
+  
+  tag_callback :param do |meth, tags|
+    puts "Arguments are:"
+    tags.each do |p|
+      puts "\t[#{p.types.join ', '}] #{p.name} #{"|" if p.text } #{p.text}"
+    end
+  end
+  
+  tag_callback :tags do |meth, tags|
+    puts "Tagged with: #{tags.map {|t| t.tags }.join ', '}"
+  end
+end

data/lib/amp/support/generator.rb

@@ -0,0 +1,78 @@
+##
+# Stolen/heavily modified from 
+# http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/140603
+# Thanks man
+
+##
+# Example generator. Note that we put +nil+ at the end to indicate the end of generation.
+# class Fibonacci < Generator
+#   def generator_loop
+#     previous, current=0,1
+#     10.times do
+#  
+#       # works
+#       yield_gen current
+#       previous, current = current, previous + current
+#     end
+#     nil
+#   end
+# end
+
+##
+# Generic generator. woo. Implement +generator_loop+ to make a concrete subclass.
+#
+# Allows you to create an object that lazily generates values and yields them 
+# when the next() method is called. 
+class Generator
+  
+  ##
+  # Generic initializer for a Generator. If you subclass, you must caller super
+  # to initialize the continuation ivars.
+  def initialize
+	  @current_context = nil
+	  reset
+  end
+  
+  ##
+  # Runs the next iteration of the generator. Uses continuations to jump across
+  # the stack all willy-nilly like.
+  #
+  # @return [Object] the next generated object.
+  def next
+    # by setting @current_context to +here+, when @current_context is called, next() will
+    # return to its caller.
+    callcc do |here|
+      @current_context = here
+      if @yield_context
+        # Run next iteration of the running loop
+        @yield_context.call
+      else
+        # Start the loop
+        generator_loop
+	    end
+    end
+  end
+  
+  ##
+  # Resets the generator from the beginning
+  def reset
+    @yield_context = nil
+  end
+  
+  private
+  
+  ##
+  # Yields a value from within the generator_loop method to the caller of +next+.
+  # This method actually is what returns a value from a call to next through the
+  # roundabout nature of continuations.
+  #
+  # @param value the value to return from +next+
+  def yield_gen(value)
+    callcc do |cont|
+      @yield_context = cont
+      @current_context.call value # causes next() to immediately return +value+
+    end
+  end
+  
+end
+

data/lib/amp/support/ignore.rb

@@ -0,0 +1,144 @@
+module Amp
+  module Ignore
+    extend self
+    
+    COMMENT = /((^|[^\\])(\\\\)*)#.*/
+    SYNTAXES = {'re' => :regexp, 'regexp' => :regexp, 'glob' => :glob,
+                'relglob' => :relglob, 'relre' => :regexp, 'path' => :glob,
+                'relpath' => :relglob}
+    ##
+    # Parses the ignore file, +file+ (or ".hgignore")
+    # 
+    # @param [String] root the root of the repo
+    # @param [Array<String>] files absolute paths to files
+    def parse_ignore(root, files=[])
+      patterns = {} # not sure what this is
+      
+      files.each do |file|
+        syntax = 're' # default syntax 
+        text = File.read File.join(root,file) rescue next
+        pattern = matcher_for_text text
+        patterns[file] = pattern if pattern
+      end # files.each
+      
+      all_patterns = patterns.values.flatten
+      # let the system know that nothing is ignored
+      return proc { false } if all_patterns.empty?
+      # here's the proc to do the tests
+      regexps_to_proc all_patterns
+    end
+    
+    ##
+    # Parse the lines into valid syntax
+    # 
+    # @param [String] file and open file
+    def parse_lines(text)
+      lines = text.split("\n").map do |line|
+        if line =~ /#/
+          line.sub! COMMENT, "\\1"
+          line.gsub! "\\#", "#"
+        end
+        
+        line.rstrip!
+        line.empty? ? nil : line
+      end
+      lines.compact
+    end
+    
+    ##
+    # Produces an array of regexps which can be used
+    # for matching files
+    # 
+    # @param [String] text the text to parse
+    # @return [[Regexp]] the regexps generated from the strings and syntaxes
+    def matcher_for_text(text)
+      return [] unless text
+      syntax = nil
+      patterns = parse_lines(text).map do |line|
+        next if line.empty?
+        # check for syntax changes
+        if line =~ /^syntax:/
+          syntax = SYNTAXES[line[7..-1].strip] || :regexp
+          next # move on
+        end
+        parse_line syntax, line # could be nil, so we need to compact it
+      end # parsed_lines(text)
+      patterns.compact # kill the nils
+    end
+    
+    ##
+    # Much like matcher_for_text, except tailored to single line strings
+    # 
+    # @see matcher_for_text
+    # @param [String] string the string to parse
+    # @return [Regexp] the regexps generated from the strings and syntaxes
+    def matcher_for_string(string)
+      scanpt = string =~ /(\w+):(.+)/
+      if scanpt.nil?
+        # just a line, no specified syntax
+        syntax = 'regexp'
+        # no syntax, the whole thing is a pattern
+        include_regexp = string   
+      else
+        syntax = $1               # the syntax is the first match
+        include_regexp = $2.strip # the rest of the string is the pattern
+      end
+      include_syntax = syntax.to_sym
+      parse_line include_syntax, include_regexp
+    end
+    
+    ##
+    # Turns a single line, given a syntax, into either
+    # a valid regexp or nil. If it is nil, it means the
+    # syntax was incorrect.
+    # 
+    # @param [Symbol] syntax the syntax to parse with (:regexp, :glob, :relglob)
+    # @param [String] line the line to parse
+    # @return [NilClass, Regexp] nil means the syntax was a bad choice
+    def parse_line(syntax, line)
+      return nil unless syntax
+      
+      # find more valid syntax stuff
+      # we need to make everything here valid regexps
+      case syntax.to_sym
+      when :regexp
+        # basic regex
+        pattern = /#{line}/
+      when :glob, :relglob
+        # glob: glob (shell style), relative to the root of the repository
+        # relglob: glob, except we just match somewhere in the string, not from the root of
+        # the repository
+        ps = line.split '/**/'
+        ps.map! do |l|
+          parts = l.split '*' # split it up and we'll escape all the parts
+          parts.map! {|p| Regexp.escape p }
+          /#{parts.join '[^/]*'}/ # anything but a slash, ie, no change in directories
+        end
+        joined = ps.join '/(?:.*/)*'
+        pattern = (syntax.to_sym == :glob) ? /^#{joined}/ : /#{joined}/
+      else
+        pattern = nil
+      end
+      
+      pattern
+    end
+    
+    ##
+    # Converts all the ignored regexps into a proc that matches against all of these
+    # regexps. That way we can pass around a single proc that checks if a file is ignored.
+    #
+    # @param [Array<Regexp>] regexps all of the regexes that we need to match against
+    # @return [Proc] a proc that, when called with a file's path, will return whether
+    #   it matches any of the regexps.
+    def regexps_to_proc(*regexps)
+      regexps = regexps.flatten.compact # needed because of possible nils
+      if regexps.empty?
+        proc { false }
+      else
+        proc { |file| regexps.any? {|p| file =~ p } }
+      end
+    end
+    alias_method :regexp_to_proc, :regexps_to_proc
+    
+  end
+end

data/lib/amp/support/loaders.rb

@@ -0,0 +1,93 @@
+# taken straight from the need gem!
+# need takes a block which should contain a string of the relative path to the file
+# you wish to need.
+$times = []
+
+##
+# Loads a given file, relative to the directory of the file executing the need statement.
+#
+# @example need { "silly.rb" }
+# @example need("silly.rb")
+# @param [String] file the file to load
+def need(file=nil, &block)
+  # do some timing if we're still benchmarking
+  s = Time.now if ENV["TESTING"] == "true"
+  
+  if block_given?
+    if RUBY_VERSION < "1.9" && (!defined?(RUBY_ENGINE) || RUBY_ENGINE != 'rbx')
+      require File.expand_path(File.join(File.dirname(eval("__FILE__", block.binding)),block.call)) # 1.9 hack
+    else
+      require File.expand_path(File.join(File.dirname(caller_file(0)),block.call))
+    end
+  elsif file
+    require File.expand_path(File.join(File.dirname(__FILE__),file))
+  end
+  # do some timing if we're still benchmarking
+  $times << [Time.now - s, block ? block.call : file]  if ENV["TESTING"] == "true"
+end
+
+##
+# Loads an entire directory, relative to the caller's file
+#
+# @example require_dir { "commands/**/*.rb" }
+# @param [String] dir the directory, in glob format, to load
+# @yield returns the string of the directory
+def require_dir(dir=nil, &block)
+  # do some timing if we're still benchmarking
+  s = Time.now if ENV["TESTING"] == "true"
+  
+  if block_given?
+    Dir[File.join(Amp::CODE_ROOT, block.call)].each do |f|
+      unless File.directory? f
+        f = f[Amp::CODE_ROOT.size+1..-1]
+        require f
+      end
+    end
+  else
+    Dir[dir].each {|f| require f unless File.directory? f }
+  end
+  
+  # do some timing if we're still benchmarking
+  $times << [Time.now - s, block ? block.call : file]  if ENV["TESTING"] == "true"
+end
+
+##
+# Finds the caller's file path. +level+ specifies how far down the call stack to look.
+#
+# @param [Fixnum] level the point in the call stack to look - 0 = top, 1 = caller, etc.
+# @return [String, NilClass] the path to the caller function's file.
+def caller_file(level=0)
+  if caller[level] # call stack big enough?
+    if RUBY_VERSION < "1.9" # this is for 1.8
+      File.expand_path(caller[level].split(":").first)
+    else
+      File.expand_path(caller[level+1].split(":").first)
+    end
+  end # returns nil by default
+end
+private :caller_file
+
+##
+# Loads a C extension, or an alternate file if the C cannot be loaded for any reason
+# (such as the user not compiling it).
+#
+# @param [String] path_to_c the path to the C library. Will be loaded relative to
+#   the caller's file.
+# @param [String] path_to_alt the path to the pure ruby version of the C library. Will
+#   be loaded relative to the caller's file
+def amp_c_extension(path_to_c, path_to_alt)
+  
+  if $USE_RUBY
+    Amp::UI.debug "Loading alternative ruby: #{path_to_alt}"
+    require File.join(File.dirname(caller_file(1)), path_to_alt)
+    return
+  end
+  
+  begin
+    offset = RUBY_VERSION < "1.9" ? 1 : 0
+    require File.expand_path(File.join(File.dirname(caller_file(offset)), path_to_c))
+  rescue LoadError # C Version could not be found, try ruby version
+    Amp::UI.debug "Loading alternative ruby: #{path_to_alt}"
+    require File.join(File.dirname(caller_file(1)), path_to_alt)
+  end
+end

data/lib/amp/support/logger.rb

@@ -0,0 +1,103 @@
+require 'delegate'
+require 'logger'
+module Amp
+  module Support
+    module SingletonLogger
+      attr_accessor :singleton_object
+      def global_logger
+        singleton_object
+      end
+      
+      def warn(*args);  global_logger.warn(*args);  end
+      def info(*args);  global_logger.info(*args);  end
+      def fatal(*args); global_logger.fatal(*args); end
+      def error(*args); global_logger.error(*args); end
+      def debug(*args); global_logger.debug(*args); end
+      
+      def method_missing(meth, *args, &block)
+        if global_logger.respond_to?(meth)
+          global_logger.__send__(meth, *args, &block)
+        else
+          super
+        end
+      end
+    end
+    
+    class IOForwarder
+      def initialize(output)
+        @output = output
+      end
+      
+      def warn(input); @output.puts(input); end
+      def info(input); @output.puts(input); end
+      def fatal(input); @output.puts(input); end
+      def error(input); @output.puts(input); end
+      def debug(input); @output.puts(input); end
+    end
+    
+    class Logger < DelegateClass(::Logger)
+      extend SingletonLogger
+      
+      def initialize(output)
+        @show_times = true
+        @output = output
+        @source = ::Logger.new(output)
+        @indent = 0
+        super(@source)
+        self.class.singleton_object = self
+      end
+      
+      def show_times=(bool)
+        if @show_times && !bool # turn off times
+          @normal_source = @source
+          @source = IOForwarder.new(@output)
+        elsif !@show_times && bool # turn it back on
+          @source = @normal_source
+        end
+      end
+      
+      def section(section_name)
+        info("<#{section_name}>").indent
+        yield
+        outdent.info("</#{section_name}>")
+      end
+      
+      def indent
+        @indent += 1
+        self
+      end
+      
+      def outdent
+        @indent -= 1
+        self
+      end
+      
+      def warn(input);  @source.warn( "\t\t"*@indent + input); self; end
+      def info(input);  @source.info( "\t\t"*@indent + input); self; end
+      def fatal(input); @source.fatal("\t\t"*@indent + input); self; end
+      def error(input); @source.error("\t\t"*@indent + input); self; end
+      def debug(input); @source.debug("\t\t"*@indent + input); self; end
+      
+      
+      def level=(level)
+        receiver = @source
+        case level
+        when :warn
+          receiver.level = ::Logger::WARN
+        when :fatal
+          receiver.level = ::Logger::FATAL
+        when :error
+          receiver.level = ::Logger::ERROR
+        when :info
+          receiver.level = ::Logger::INFO
+        when :debug
+          receiver.level = ::Logger::DEBUG
+        when :none
+          receiver.level = ::Logger::UNKNOWN
+        else
+          receiver.level = level
+        end
+      end
+    end
+  end
+end