amp 0.5.2 → 0.5.3

data/lib/amp/revlogs/revlog_support.rb

@@ -1,126 +0,0 @@
-autoload :Zlib, 'zlib'
-module Amp
-  module RevlogSupport
-    
-    class RevlogError < StandardError; end
-    class LookupError < StandardError; end
-    
-    module Support
-      extend self
-      
-      # Old version of the revlog file format
-      REVLOG_VERSION_0 = 0
-      # Current version of the revlog file format
-      REVLOG_VERSION_NG = 1
-      # A flag marking that the data is stored with the index
-      REVLOG_NG_INLINE_DATA = (1 << 16)
-      # Default flags - always start inline (turn off inline if file is huge)
-      REVLOG_DEFAULT_FLAGS = REVLOG_NG_INLINE_DATA
-      # Default format - the most recent
-      REVLOG_DEFAULT_FORMAT = REVLOG_VERSION_NG
-      # Default version in general
-      REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT | REVLOG_DEFAULT_FLAGS
-      
-      ##
-      # This bears some explanation.
-      #
-      # Rather than simply having a 4-byte header for the index file format, the
-      # Mercurial format takes the first entry in the index, and stores the header
-      # in its offset field. (The offset field is a 64-bit unsigned integer which
-      # stores the offset into the data or index of the associated record's data)
-      # They take advantage of the fact that the first entry's offset will always
-      # be 0. As such, its offset field is always going to be zero, so it's safe
-      # to store data there.
-      #
-      # The format is ((flags << 16) | (version)), where +flags+ is a bitmask (up to 48
-      # bits) and +version+ is a 16-bit unsigned short.
-      #
-      # The worst part is, EVERY SINGLE ENTRY has its offset shifted 16 bits to the left,
-      # apparently all because of this. It fucking baffles my mind. 
-      #
-      # So yeah. offset = value >> 16.
-      def get_offset(o); o >> 16; end
-      # And yeah. version = value && 0xFFFF (last 16 bits)
-      def get_version(t); t & 0xFFFF; end
-      
-      # Combine an offset and a version to spit this baby out
-      def offset_version(offset,type)
-        (offset << 16) | type
-      end
-      
-      ##
-      # generate a hash from the given text and its parent hashes
-      # 
-      # This hash combines both the current file contents and its history
-      # in a manner that makes it easy to distinguish nodes with the same
-      # content in the revision graph.
-      # 
-      # since an entry in a revlog is pretty
-      # much [parent1, parent2, text], we use a hash of the previous entry
-      # as a reference to that previous entry. To create a reference to this
-      # entry, we make a hash of the first parent (which is just its ID), the
-      # second parent, and the text.
-      # 
-      # @return [String] the digest of the two parents and the extra text
-      def history_hash(text, p1, p2)
-        list = [p1, p2].sort
-        s = list[0].sha1
-        s.update list[1]
-        s.update text
-        s.digest
-      end
-      
-      ##
-      # returns the possibly-compressed version of the text, in a hash:
-      # 
-      # @return [Hash] :compression => 'u' or ''
-      def compress(text)
-        return {:compression => "", :text => text} if text.empty?
-        size = text.size
-        binary = nil
-        if size < 44
-        elsif size > 1000000 #big ole file
-          deflater = Zlib::Deflate.new
-          parts = []
-          position = 0
-          while position < size
-            newposition = position + 2**20
-            parts << deflater.deflate(text[position..(newposition-1)], Zlib::NO_FLUSH)
-            position = newposition
-          end
-          parts << deflater.flush
-          binary = parts.join if parts.map {|e| e.size}.sum < size # only add it if
-                                                 # compression made it smaller
-        else #tiny, just compress it
-          binary = Zlib::Deflate.deflate text
-        end
-        
-        if binary.nil? || binary.size > size
-          return {:compression => "",  :text => text} if text[0,1] == "\0"
-          return {:compression => 'u', :text => text}
-        end
-        {:compression => "", :text => binary}
-      end
-      
-      ##
-      # Decompresses the given binary text. The binary text could be
-      # uncompressed, in which case, we'll figure that out. Don't worry.
-      # 
-      # @param [String] binary the text to (possibly) decompress
-      # @return [String] the text decompressed
-      def decompress(binary)
-        return binary if binary.empty?
-        case binary[0,1]
-        when "\0"
-          binary #we're just stored as binary
-        when "x"
-          Zlib::Inflate.inflate(binary) #we're zlibbed
-        when "u"
-          binary[1..-1] #we're uncompressed text
-        else
-          raise LookupError.new("Unknown compression type #{binary[0,1]}")
-        end
-      end
-    end
-  end
-end

data/lib/amp/support/ignore.rb

@@ -1,144 +0,0 @@
-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/site/Rakefile

@@ -1,38 +0,0 @@
-# -*- ruby -*-
-
-require 'rubygems'
-require 'rake'
-require 'rake/tasklib'
-
-require 'src/helpers.rb'
-require 'ftools'
-
-desc "Compile Site"
-task :"build-website" do
-  missing_gems = []
-  requirements = ['haml', 'uv']
-  requirements.each do |requirement|
-    begin
-      require requirement
-    rescue LoadError => e
-      puts "The following gems are required to build the amp website: #{requirements.join(", ")}"
-      puts "Install them as follows: gem install #{requirements.join(" ")}"
-      exit
-    end
-  end
-  Dir["src/**/*.haml"].reject {|item| item.split("/").last =~ /^_/}.each do |haml|
-    FileUtils.makedirs(File.dirname("build" + haml[3..-6] + ".html"))
-    File.open("build" + haml[3..-6] + ".html","w") do |out|
-      puts "Building #{haml[3..-6]}"
-      out.write render(haml)
-    end
-  end
-  %w(css images scripts docs).each do |dir|
-    if File.exist? "src/#{dir}/"
-      sh "cp -r src/#{dir}/ build/#{dir}/"
-    end
-  end
-end
-
-task :default => :"build-website" do
-end

data/test/test_amp.rb

@@ -1,9 +0,0 @@
-require "test/unit"
-require File.expand_path(File.join(File.dirname(__FILE__), "../lib/amp"))
-
-class TestAmp < Test::Unit::TestCase
-  
-  def test_truth
-    assert true
-  end
-end

data/test/test_helper.rb

@@ -1,15 +0,0 @@
-require 'test/unit'
-
-def assert_false(val)
-  assert_equal(false, !!val)
-end
-
-def assert_not_nil(val)
-  assert_not_equal(nil, val)
-end
-
-def assert_file_contents(file, contents)
-  File.open(file,"r") do |f|
-    assert_equal f.read, contents
-  end
-end