amp 0.5.0

data/ext/amp/support/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+if RUBY_VERSION =~ /1.9/ then  
+    $CPPFLAGS += " -DRUBY_19"  
+end
+create_makefile("Support")

data/ext/amp/support/support.c

@@ -0,0 +1,250 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "ruby.h"
+
+static int little_endian = -1;
+
+// these defines are taken from the mercurial source. They're relatively standard for
+// byte-swapping, but credit goes where credit's due.
+#ifdef _WIN32
+# ifdef _MSC_VER
+/* msvc 6.0 has problems */
+#  define inline __inline
+typedef unsigned long uint32_t;
+typedef unsigned __int64 uint64_t;
+# else
+#  include <stdint.h>
+# endif
+static uint32_t ntohl(uint32_t x)
+{
+	return ((x & 0x000000ffUL) << 24) |
+	       ((x & 0x0000ff00UL) <<  8) |
+	       ((x & 0x00ff0000UL) >>  8) |
+	       ((x & 0xff000000UL) >> 24);
+}
+#else
+/* not windows */
+# include <sys/types.h>
+# if defined __BEOS__ && !defined __HAIKU__
+#  include <ByteOrder.h>
+# else
+#  include <arpa/inet.h>
+# endif
+# include <inttypes.h>
+#endif
+
+/**
+ * Byte-swaps a 64-bit fixnum.
+ * Bignum arithmetic is quite, quite slow. By implementing this in C, we save ourselves
+ * innumerable cycles. Also, our result will usually end up being a bignum, even though we
+ * start as a fixnum.
+ * 
+ * @param self [in] the bignum that needs byte swapping
+ * @return the byte-swapped number (or not swapped if host is big-endian)
+ */
+static VALUE amp_fixnum_byte_swap_64(VALUE self) {
+    VALUE result = self;
+    if (little_endian) {
+    uint64_t val = (uint64_t)FIX2ULONG(self);
+    val = (((val >> 56)) | ((val & 0x00FF000000000000ll) >> 40) |
+         ((val & 0x0000FF0000000000ll) >> 24) | ((val & 0x000000FF00000000ll) >> 8)  |
+         ((val & 0x00000000FF000000ll) << 8 ) | ((val & 0x0000000000FF0000ll) << 24) |
+         ((val & 0x000000000000FF00ll) << 40) | ((val & 0x00000000000000FFll) << 56));
+     result = rb_ull2inum(val);
+    }
+    return result;
+}
+
+/**
+ * Converts an unsigned, 16-bit fixnum to a signed, 16-bit value.
+ * Converts an unsigned, 16-bit number to its signed equivalent.
+ * Since Ruby doesn't have signed values readily available, this is much 
+ * much faster in C.
+ *
+ * @param self [in] the 16-bit unsigned short to make signed
+ * @return the 16-bit signed equivalent
+ */
+static VALUE amp_fixnum_to_signed_16(VALUE self) {
+    signed short val = (int16_t)FIX2INT(self);
+    VALUE result = rb_int_new(val);
+    return result;
+}
+
+/**
+ * Converts a fixnum to a signed, 32-bit value.
+ * Converts an unsigned, 32-bit number to its signed equivalent. Since Ruby
+ * doesn't have signed values readily available, this is much much faster in
+ * C. This will only be called if the number being converted is smaller than
+ * the fixnum max.
+ *
+ * @param self [in] the 32-bit unsigned long to make signed
+ * @return the 32-bit signed equivalent
+ */
+static VALUE amp_fixnum_to_signed_32(VALUE self) {
+    VALUE result = rb_int_new((int32_t)FIX2LONG(self));
+    return result;
+}
+
+/**
+ * Byte-swaps a 64-bit bignum.
+ * Bignum arithmetic is quite, quite slow. By implementing this in C, we save ourselves
+ * innumerable cycles.
+ * 
+ * @param self [in] the bignum that needs byte swapping
+ * @return the byte-swapped bignum (or not swapped if host is big-endian)
+ */
+static VALUE amp_bignum_byte_swap_64(VALUE self) {
+    VALUE result = self;
+    if (little_endian) {
+    uint64_t val = rb_big2ull(self);
+    val = (((val >> 56)) | ((val & 0x00FF000000000000ull) >> 40) |
+         ((val & 0x0000FF0000000000ull) >> 24) | ((val & 0x000000FF00000000ull) >> 8)  |
+         ((val & 0x00000000FF000000) << 8 ) | ((val & 0x0000000000FF0000) << 24) |
+         ((val & 0x000000000000FF00) << 40) | ((val & 0x00000000000000FF) << 56));
+     result = rb_ull2inum(val);
+    }
+    return result;
+}
+
+/**
+ * Converts a bignum to a signed, 32-bit value.
+ * Converts an unsigned, 32-bit number to its signed equivalent. Since Ruby
+ * doesn't have signed values readily available, this is much much faster in
+ * C.
+ *
+ * @param self [in] the 32-bit unsigned long to make signed
+ * @return the 32-bit signed equivalent
+ */
+static VALUE amp_bignum_to_signed_32(VALUE self) {
+    VALUE result = rb_int_new((int32_t)rb_big2ulong(self));
+    return result;
+}
+
+/**
+ * Converts a bignum to a signed, 16-bit value.
+ * Converts an unsigned, 16-bit number to its signed equivalent.
+ * This should actually never be called, because bignums shouldn't
+ * ever be used for 16-bit values. However, it's provided just to be safe.
+ * Since Ruby doesn't have signed values readily available, this is much 
+ * much faster in C.
+ *
+ * @param self [in] the 16-bit unsigned short to make signed
+ * @return the 16-bit signed equivalent
+ */
+static VALUE amp_bignum_to_signed_16(VALUE self) {
+    signed short val = (int16_t)rb_big2ulong(self); // cut off bytes
+    VALUE result = rb_int_new(val);
+    return result;
+}
+
+// constant symbols that our dirstate would like
+static VALUE rb_sRemoved, rb_sUntracked, rb_sNormal, rb_sMerged, rb_sAdded;
+
+/**
+ * Converts an ascii value to a dirstate status symbol.
+ * Converts a fixnum, which is an ascii value, to a symbol representing
+ * a dirstate entry's status. Since we don't like passing around 'n', and
+ * want to pass around :normal, we need a fast lookup for ascii value ->
+ * symbol. The price we pay.
+ *
+ * @param self [in] the integer ascii value to convert
+ * @return a symbol representation of the dirstate status
+ */
+static VALUE amp_integer_to_dirstate_symbol(VALUE self) {
+    int val = NUM2INT(self);
+    switch (val) {
+        case 110: return rb_sNormal;   // 'n'
+        case 63: return rb_sUntracked; // '?'
+        case 97: return rb_sAdded;     // 'a'
+        case 109: return rb_sMerged;   // 'm'
+        case 114: return rb_sRemoved;  // 'r'
+    }
+    rb_raise(rb_eStandardError, "no known hg value for %d", val);
+}
+
+/**
+ * Converts a string of hexademical into its binary representation.
+ * Method on strings. When the data in the string is hexademical
+ * (such as "DEADBEEF"), this method decodes the hex and converts
+ * every 2 bytes into its 1-byte binary representation.
+ *
+ * @example "414243".unhexlify == "ABC"
+ * @param self [in] the string object to unhexlify
+ * @return A decoded, binary string
+ */
+static VALUE amp_string_unhexlify(VALUE self) {
+    // lengths of our strings
+    unsigned int len, out_len;
+    VALUE out;
+    // byte buffers that we'll work with when unhexlifying
+    char *out_buf, *in_buf;
+    char chk;
+    
+    len = RSTRING_LEN(self);
+    // 2 hex bytes -> 1 unhexlified byte
+    out_len = len / 2;
+    out = rb_str_new(NULL, out_len);
+    
+    // mark it as modified otherwise the GC will wig out at us
+    rb_str_modify(out);
+    // snag some pointers so we can do bad things
+    in_buf  = RSTRING_PTR(self);
+    out_buf = RSTRING_PTR(out);
+    
+    while (len) {
+        // first byte is multiplied by 16
+        chk = *in_buf++;
+        if (chk >= '0' && chk <= '9')
+            *out_buf = 16 * (chk - '0');
+        else if (chk >= 'A' && chk <= 'F')
+            *out_buf = 16 * (chk - 'A' + 10);
+        else if (chk >= 'a' && chk <= 'f')
+            *out_buf = 16 * (chk - 'a' + 10);
+        // second byte is just added to result
+        chk = *in_buf++;
+        if (chk >= '0' && chk <= '9')
+            *out_buf += (chk - '0');
+        else if (chk >= 'A' && chk <= 'F')
+            *out_buf += (chk - 'A' + 10);
+        else if (chk >= 'a' && chk <= 'f')
+            *out_buf += (chk - 'a' + 10);
+        out_buf++;
+        // 2 hex bytes down
+        len -= 2;
+    }
+    return out;
+}
+
+/**
+ * Initializes the Support module's C extension.
+ * This function is the entry point to the module - when the code is require'd,
+ * this function is run. All we need to do is add the new methods, and look up the
+ * symbols for to_dirstate_symbol.
+ */
+void Init_Support() {
+    if (little_endian == -1) little_endian = (ntohl(8) != 8);
+
+    // methods added to String class
+    rb_define_method(rb_cString, "unhexlify", amp_string_unhexlify, 0);
+    
+    // methods added to the Bignum class
+    rb_define_method(rb_cBignum, "byte_swap_64", amp_bignum_byte_swap_64, 0);
+    rb_define_method(rb_cBignum, "to_signed_32", amp_bignum_to_signed_32, 0);
+    rb_define_method(rb_cBignum, "to_signed_16", amp_bignum_to_signed_16, 0);
+
+    // methods added to the Fixnum class
+    rb_define_method(rb_cFixnum, "byte_swap_64", amp_fixnum_byte_swap_64, 0);
+    rb_define_method(rb_cFixnum, "to_signed_32", amp_fixnum_to_signed_32, 0);
+    rb_define_method(rb_cFixnum, "to_signed_16", amp_fixnum_to_signed_16, 0);
+    
+    // Since symbols are only ever created once, let's look them up now, and never
+    // look them up again!
+    rb_sRemoved   = ID2SYM(rb_intern("removed"));
+    rb_sUntracked = ID2SYM(rb_intern("untracked"));
+    rb_sNormal    = ID2SYM(rb_intern("normal"));
+    rb_sMerged    = ID2SYM(rb_intern("merged"));
+    rb_sAdded     = ID2SYM(rb_intern("added"));
+    
+    // method added to the Integer class
+    rb_define_method(rb_cInteger, "to_dirstate_symbol", amp_integer_to_dirstate_symbol, 0);
+}

data/lib/amp.rb

@@ -0,0 +1,200 @@
+module Amp; end
+# The root directory of this application
+Amp::CODE_ROOT = File.expand_path File.dirname(__FILE__)
+$: << Amp::CODE_ROOT # now we don't need to do `require "#{curdir}..."
+
+# Timing variable
+$start    ||= Time.now
+# Should we display anything?
+$display  ||= false
+# Should we use pure ruby? Default to no.
+$USE_RUBY ||= false
+# Are we a command-line app? Default to no.
+$cl ||= false
+
+require "amp/support/loaders.rb"
+
+#require 'profile'
+require 'fileutils'
+require 'stringio'
+
+local_start = Time.now
+
+
+###############
+# The Amp Magic
+###############
+module Amp
+  
+  autoload :Hook,                      "amp/commands/hooks.rb"
+  autoload :Generator,                 "amp/support/generator.rb"
+  autoload :Opener,                    "amp/support/openers.rb"
+  autoload :Match,                     "amp/support/match.rb"
+  autoload :Ignore,                    "amp/support/ignore.rb"
+  autoload :AmpConfig,                 "amp/support/amp_config.rb"
+  autoload :UI,                        "amp/support/amp_ui.rb"
+                                        
+  autoload :Journal,                   "amp/repository/journal.rb"
+  autoload :VersionedFile,             "amp/repository/versioned_file.rb"
+  autoload :VersionedWorkingFile,      "amp/repository/versioned_file.rb"
+  
+  autoload :Revlog,                    "amp/revlogs/revlog.rb"      
+  autoload :Manifest,                  "amp/revlogs/manifest.rb"
+  autoload :FileLog,                   "amp/revlogs/file_log.rb"
+  autoload :Changeset,                 "amp/revlogs/changeset.rb"
+  autoload :WorkingDirectoryChangeset, "amp/revlogs/changeset.rb"
+  autoload :ChangeGroup,               "amp/revlogs/changegroup.rb"
+  autoload :ChangeLog,                 "amp/revlogs/changelog.rb"
+  
+  module Bundles
+    autoload :BundleChangeLog,         "amp/revlogs/bundle_revlogs.rb"
+    autoload :BundleFileLog,           "amp/revlogs/bundle_revlogs.rb"
+    autoload :BundleManifest,          "amp/revlogs/bundle_revlogs.rb"
+    autoload :BundleRevlog,            "amp/revlogs/bundle_revlogs.rb"
+  end                                      
+                                           
+  module Encoding                          
+    autoload :Base85,                  "amp/encoding/base85.rb"
+  end                                      
+                                           
+  module Diffs                             
+    autoload :BinaryDiff,              "amp/encoding/binary_diff.rb"
+    autoload :MercurialDiff,           "amp/encoding/mercurial_diff.rb"
+    autoload :MercurialPatch,          "amp/encoding/mercurial_patch.rb"
+    autoload :SequenceMatcher,         "amp/encoding/difflib.rb"
+  end
+  
+  module Graphs
+    autoload :AncestorCalculator,      "amp/graphs/ancestor.rb"
+    autoload :CopyCalculator,          "amp/graphs/copies.rb"
+  end                                      
+                                           
+  module Merges                            
+    autoload :MergeState,              "amp/merges/merge_state.rb"
+    autoload :MergeUI,                 "amp/merges/merge_ui.rb"
+    autoload :ThreeWayMerger,          "amp/merges/simple_merge.rb"
+  end                                      
+  
+  module Repositories
+    autoload :BranchManager,           "amp/repository/branch_manager.rb"
+    autoload :BundleRepository,        "amp/repository/repositories/bundle_repository.rb"
+    autoload :DirState,                "amp/repository/dir_state.rb"
+    autoload :HTTPRepository,          "amp/repository/repositories/http_repository.rb"
+    autoload :HTTPSRepository,         "amp/repository/repositories/http_repository.rb"
+    autoload :LocalRepository,         "amp/repository/repositories/local_repository.rb"
+    autoload :Lock,                    "amp/repository/lock.rb"
+    autoload :Stores,                  "amp/repository/store.rb"
+    autoload :TagManager,              "amp/repository/tag_manager.rb"
+    autoload :Updatable,               "amp/repository/updatable.rb"
+    autoload :Verification,            "amp/repository/verification.rb"
+  end                                      
+                                           
+  module RevlogSupport                     
+    autoload :ChangeGroup,             "amp/revlogs/changegroup.rb"
+    autoload :Index,                   "amp/revlogs/index.rb"
+    autoload :IndexInlineNG,           "amp/revlogs/index.rb"
+    autoload :IndexVersion0,           "amp/revlogs/index.rb"
+    autoload :IndexVersionNG,          "amp/revlogs/index.rb"
+    autoload :Node,                    "amp/revlogs/node.rb"
+    autoload :Support,                 "amp/revlogs/revlog_support.rb"
+  end
+  
+  module Servers
+    autoload :FancyHTTPServer,         "amp/server/fancy_http_server.rb"
+    autoload :HTTPServer,              "amp/server/http_server.rb"
+    autoload :HTTPAuthorizedServer,    "amp/server/http_server.rb"
+    autoload :RepoUserManagement,      "amp/server/repo_user_management.rb"
+    autoload :User,                    "amp/server/amp_user.rb"
+  end
+  
+  module Support
+    autoload :Logger,                  "amp/support/logger.rb"
+    autoload :MultiIO,                 "amp/support/multi_io.rb"
+    autoload :Template,                "amp/templates/template.rb"
+  end
+end
+
+#######################
+# Sinatra modifications
+#######################
+module Sinatra
+  autoload :Amp, "amp/server/extension/amp_extension.rb"
+end                  
+
+
+###########################
+# Globally accessible tools
+###########################
+autoload :Archive,       "amp/dependencies/minitar.rb"
+autoload :Zip,           "amp/dependencies/zip/zip.rb"
+autoload :PriorityQueue, "amp/dependencies/priority_queue.rb"
+
+#############################
+# Files we need to just *run*
+#############################                 
+require "amp/dependencies/trollop.rb"         
+require "amp/dependencies/python_config.rb"   
+require "amp/dependencies/amp_support.rb"     
+require "amp/support/ruby_19_compatibility.rb"
+require "amp/support/support.rb"              
+require "amp/templates/template.rb"
+
+if $cl # if it's a command line app
+  include Amp::KernelMethods
+  require       "amp/commands/command.rb"
+  require_dir { "amp/commands/*.rb"              }
+  require_dir { "amp/commands/commands/*.rb"     }
+  
+else
+  # it's not a command line app
+ require     'amp/support/docs.rb' # live documentation access
+end
+require      "amp/repository/repository.rb"
+
+module Amp
+  VERSION = '0.5.0'
+  VERSION_TITLE = "John Locke"
+  
+  def self.new_irb_session(bndng)
+    require 'irb'
+    
+    # Alter IRB appropriately
+    # http://jameskilton.com/2009/04/02/embedding-irb-into-your-ruby-application/
+    ::IRB.class_eval do
+      def self.start_session(binding)
+        unless @__initialized
+          args = ARGV
+          ARGV.replace(ARGV.dup)
+          IRB.setup(nil)
+          ARGV.replace(args)
+          @__initialized = true
+        end
+
+        workspace = WorkSpace.new(binding)
+
+        irb = Irb.new(workspace)
+
+        @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+        @CONF[:MAIN_CONTEXT] = irb.context
+
+        catch(:IRB_EXIT) do
+          irb.eval_input
+        end
+      end
+    end
+    
+    IRB::start_session bndng
+  end
+  
+end
+
+if ENV["TESTING"] == "true"
+  paused = Time.now
+  Amp::UI.debug "Time taken to load all files: #{paused - $start} seconds"
+  Amp::UI.debug "\t\t local files: #{paused - local_start} seconds"
+  Amp::UI.debug
+  Amp::UI.debug
+end
+
+# Benchmarking stuff
+#need { 'amp/profiling_hacks' }