amp-core 0.1.0

data/lib/amp-core/repository/abstract/common_methods/versioned_file.rb

@@ -0,0 +1,87 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+module Amp
+  module Core
+    module Repositories
+    
+      ##
+      # = CommonVersionedFileMethods
+      #
+      # These methods are common to all repositories, and this module is mixed into
+      # the AbstractLocalRepository class. This guarantees that all repositories will
+      # have these methods.
+      #
+      # No methods should be placed into this module unless it relies on methods in the
+      # general API for repositories.
+      module CommonVersionedFileMethods
+      
+        def unified_diff_with(other_vf, opts = {})    
+          Diffs::Mercurial::MercurialDiff.unified_diff(self.data, self.changeset.easy_date, 
+                                                       other_vf.data, other_vf.changeset.easy_date,
+                                                       self.path, other_vf.path || "/dev/null", 
+                                                       false, opts)
+        end
+      
+        ##
+        # Compares two versioned files - namely, their data.
+        # 
+        # @param [VersionedFile] other what to compare to
+        # @return [Boolean] true if the two are the same
+        def ===(other)
+          self.path == other.path &&
+          self.data == other.data
+        end
+      
+        # Returns if the file has been changed since its parent. Slow.
+        # If your implementation has a fast way of doing this, we recommend
+        # you override this method.
+        #
+        # @return [Boolean] has the file been changed since its parent?
+        def clean?
+          self === parents.first
+        end
+        opposite_method :dirty?, :clean?
+      
+        ##
+        # User who committed this revision to this file
+        # 
+        # @return [String] the user
+        def user; changeset.user; end
+      
+        ##
+        # Date this revision to this file was committed
+        # 
+        # @return [DateTime]
+        def date; changeset.date; end
+      
+        ##
+        # The description of the commit that contained this file revision
+        # 
+        # @return [String]
+        def description; changeset.description; end
+      
+        ##
+        # The branch this tracked file belongs to
+        # 
+        # @return [String]
+        def branch; changeset.branch; end
+      
+        ##
+        # Working directory has no children!
+        def children; []; end
+      end
+    end
+  end
+end

data/lib/amp-core/repository/generic_repo_picker.rb

@@ -0,0 +1,94 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+module Amp
+  module Core
+    module Repositories
+    
+      ##
+      # This class is a generic "repo picker". It will return a Repository object
+      # for the given path (if there is one), and is capable of telling you if there
+      # is a repository of its type in the given directory.
+      #
+      # Amp started off with a MercurialPicker - it knows how to find Mercurial repos.
+      #
+      # When amp runs, it iterates over all subclasses of AbstractRepoPicker, in no
+      # guaranteed order (so don't stomp on existing pickers!), calling #repo_in_dir? .
+      # If only one picker returns +true+, then that picker is used for opening the
+      # repository. If more than one returns +true+, the user's configuration is consulted.
+      # If nothing is found then, then the user is prompted. When the final picker has been
+      # chosen, its #pick method is called to get the repository for the directory/URL.
+      #
+      # This is an "abstract" class, in that all the methods will raise a NotImplementedError
+      # if you try to call them.
+      #
+      # You must subclass this class, or your custom repo code will be ignored by Amp's
+      # dispatch system.
+      class GenericRepoPicker
+        @all_pickers = []
+        class << self
+          include Enumerable
+          attr_accessor :all_pickers
+        
+          ##
+          # Iterate over every RepoPicker in the system.
+          def each(*args, &block)
+            @all_pickers.each(*args, &block)
+          end
+        
+          private
+        
+          ##
+          # Assuming you're a Ruby Newbie reading this: The interpreter calls
+          # {{inherited}} on the superclass when a class is subclassed.
+          # 
+          # For the non-newbies, we're just keeping track of all subclasses so
+          # we know what classes we can pick from.
+          # 
+          # @param [Class] subclass the class that just inherited from this class
+          def inherited(subclass)
+            all_pickers << subclass.new
+          end
+        end
+      
+        ##
+        # Returns whether or not there is a repository in the given directory. This
+        # picker should only be responsible for one type of repository - git, svn, hg,
+        # etc. The given path could be deep inside a repository, and must look in parent
+        # directories for the root of the VCS repository.
+        #
+        # @param [String] path the path in which to search for a repository
+        # @return [Boolean] is there a repository in this directory (or parent directories)?
+        def repo_in_dir?(path)
+          raise NotImplementedError.new("repo_in_dir? must be implemented in a concrete subclass.")
+        end
+        alias_method :repo_in_url?, :repo_in_dir?
+
+        ##
+        # Returns a repository object for the given path. Should respond to the standard repository
+        # API to the best of its ability, and raise a CapabilityError if asked to do something it
+        # cannot do from the API.
+        #
+        # @param [AmpConfig] config the configuration of the current environment, loaded from
+        #   appropriate configuration files
+        # @param [String] path the path/URL in which to open the repository.
+        # @param [Boolean] create should a repository be created in the given directory/URL?
+        # @return [AbstractLocalRepository] the repository for the given URL
+        def pick(config, path = '', create = false)
+          raise NotImplementedError.new("repo_in_dir? must be implemented in a concrete subclass.")
+        end
+      end
+    end
+  end
+end

data/lib/amp-core/repository/repository.rb

@@ -0,0 +1,41 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+module Amp
+  module Core
+    module Repositories
+      class RepoError < StandardError; end
+    
+      ##
+      # Picks a repository provided a user configuration, a path, and whether
+      # we have permission to create the repository.
+      #
+      # This is the entry point for repo-independent command dispatch.  We need
+      # to know if the given repository is of a particular type. We iterate
+      # over all known types, ask each type "does this path look like your kind
+      # of repo?", and if it says "yes", use that type.
+      #
+      # Note: this does NOT handle when there are two types of repositories in
+      # a given directory.
+      def self.pick(config, path='', create=false)
+        GenericRepoPicker.each do |picker|
+          return picker.pick(config, path, create) if picker.repo_in_dir?(path)
+        end
+      
+        # We have found... nothing
+        nil
+      end # def self.pick
+    end # module Repositories
+  end # module Core
+end # module Amp

data/lib/amp-core/support/encoding_utils.rb

@@ -0,0 +1,46 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+module Amp
+  module Core
+    module Support
+      # This module is a set of string functions that we use frequently.
+      # They sued to be monkey-patched onto the String class, but we don't
+      # do that anymore.
+      module EncodingUtils
+        module_function
+        
+        ##
+        # Used for byte-swapping a 64-bit double long.
+        # Unfortuantely, this will invoke bignum logic, which is ridiculously slow.
+        # That's why we have a C extension.
+        # 
+        # If the system is little endian, we work some magic. If the system is big
+        # endian, we just return self.
+        #
+        # @return [Integer] the number swapped as if it were a 64-bit integer
+        def network_to_host_64(src)
+          if Amp::Core::Support::Platform::SYSTEM[:endian] == :little
+            ((src >> 56))                      | ((src & 0x00FF000000000000) >> 40) |
+            ((src & 0x0000FF0000000000) >> 24) | ((src & 0x000000FF00000000) >> 8 ) |
+            ((src & 0x00000000FF000000) << 8 ) | ((src & 0x0000000000FF0000) << 24) |
+            ((src & 0x000000000000FF00) << 40) | ((src & 0x00000000000000FF) << 56)
+          else
+            src
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amp-core/support/platform_utils.rb

@@ -0,0 +1,92 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+module Amp
+  module Core
+    module Support
+      # This module is used to set a few constants regarding which OS,
+      # implementation, and architecture the user is running.
+      module Platform
+        if RUBY_PLATFORM =~ /darwin/i
+          OS = :unix
+          IMPL = :macosx
+        elsif RUBY_PLATFORM =~ /linux/i
+          OS = :unix
+          IMPL = :linux
+        elsif RUBY_PLATFORM =~ /freebsd/i
+          OS = :unix
+          IMPL = :freebsd
+        elsif RUBY_PLATFORM =~ /netbsd/i
+          OS = :unix
+          IMPL = :netbsd
+        elsif RUBY_PLATFORM =~ /mswin/i
+          OS = :win32
+          IMPL = :mswin
+        elsif RUBY_PLATFORM =~ /cygwin/i
+          OS = :unix
+          IMPL = :cygwin
+        elsif RUBY_PLATFORM =~ /mingw/i
+          OS = :win32
+          IMPL = :mingw
+        elsif RUBY_PLATFORM =~ /bccwin/i
+          OS = :win32
+          IMPL = :bccwin
+        elsif RUBY_PLATFORM =~ /wince/i
+          OS = :win32
+          IMPL = :wince
+        elsif RUBY_PLATFORM =~ /vms/i
+          OS = :vms
+          IMPL = :vms
+        elsif RUBY_PLATFORM =~ /os2/i
+          OS = :os2
+          IMPL = :os2 # maybe there is some better choice here?
+        else
+          OS = :unknown
+          IMPL = :unknown
+        end
+  
+        if RUBY_PLATFORM =~ /(i\d86)/i
+          ARCH = :x86
+        elsif RUBY_PLATFORM =~ /(x86_64|amd64)/i
+          ARCH = :x86_64
+        elsif RUBY_PLATFORM =~ /ia64/i
+          ARCH = :ia64
+        elsif RUBY_PLATFORM =~ /powerpc/i
+          ARCH = :powerpc
+        elsif RUBY_PLATFORM =~ /alpha/i
+          ARCH = :alpha
+        elsif RUBY_PLATFORM =~ /universal/i
+          ARCH = :universal
+        else
+          ARCH = :unknown
+        end
+        SYSTEM = {}
+        
+        # Figures up the system is running on a little or big endian processor
+        # architecture, and upates the SYSTEM[] hash in the Support module.
+        def self.determine_endianness
+          num = 0x12345678
+          native = [num].pack('l')
+          netunpack = native.unpack('N')[0]
+          if num == netunpack
+            SYSTEM[:endian] = :big
+          else
+            SYSTEM[:endian] = :little
+          end   
+        end
+
+        determine_endianness
+      end
+    end
+  end
+end

data/lib/amp-core/support/rooted_opener.rb

@@ -0,0 +1,143 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+module Amp
+  module Core
+    module Support
+      # This creates an opener that prepends a directory to all
+      # File opening, allowing repository formats to worry only
+      # about file paths relative to the repository root.
+      class RootedOpener
+        attr_reader :root
+        attr_accessor :create_mode
+        attr_accessor :default
+    
+        alias_method :base, :root
+    
+        ##
+        # Creates a new opener with a root of +base+, and also set to open files in
+        # the .hg subdirectory. If you set .default = :open_file, it will no longer
+        # open files in the .hg subdir.
+        # 
+        # @param [String] base the root directory of the repository this opener will be
+        #   used on
+        def initialize(base)
+          @root        = File.expand_path base
+          @create_mode = nil
+          @default     = :open_hg
+        end
+    
+        ##
+        # Returns the path to the opener's root.
+        #
+        # @return path to the opener's root, as an absolute path.
+        def path
+          case @default
+          when :open_file
+            "#{root}/"
+          when :open_hg
+            "#{root}/.hg/"
+          when :open_git
+            "#{root}/.git"
+          else
+            raise abort "Unknown opener format #{@default.inspect}"
+          end
+        end
+    
+        ##
+        # Read the file passed in with mode 'r'.
+        # Synonymous with File.open(+file+, 'r') {|f| f.read } and
+        # File.read(+file+)
+        #
+        # @param [String] file the relative path to the file we're opening
+        # @return [String] the contents of the file
+        def read(file)
+          res = nil
+          open(file, 'r') {|f| res = f.read }
+          res
+        end
+        alias_method :contents, :read
+    
+        ##
+        # Opens up the given file, exactly like you would do with File.open.
+        # The parameters are the same. Defaults to opening a file in the .hg/
+        # folder, but if @default == :open_file, will open it from the working
+        # directory.
+        #
+        # If the mode includes write privileges, then the write will use an
+        # atomic temporary file.
+        #
+        # @param [String] file the path to the file to open
+        # @param [String] mode the read/write mode to open with (standard
+        #   C choices here)
+        # @yield Can yield the opened file if the block form is used
+        def open(file, mode='r', &block)
+          if @default == :open_file
+            open_file file, mode, &block
+          else
+            open_hg file, mode, &block
+          end
+        end
+    
+        def join(file)
+          File.join(root, file)
+        end
+    
+        ##
+        # Opens a file in the .hg repository using +@root+. This method
+        # operates atomically, and ensures that the file is always closed
+        # after use. The temporary files (while being atomically written)
+        # are stored in "#{@root}/.hg", and are deleted after use. If only 
+        # a read is being done, it instead uses Kernel::open instead of
+        # File::amp_atomic_write.
+        #
+        # @param [String] file the file to open
+        # @param [String] mode the mode with which to open the file ("w", "r", "a", ...)
+        # @yield [file] code to run on the file
+        # @yieldparam [File] file the opened file
+        def open_hg(file, mode='w', &block)
+          open_up_file File.join(root, ".hg"), file, mode, &block
+        end
+    
+        ##
+        # Opens a file in the repository (not in .hg).
+        # Writes are done atomically, and reads are efficiently
+        # done with Kernel::open. THIS IS NOT +open_up_file+!!!
+        # 
+        # @param [String] file the file to open
+        # @param [String] mode the mode with which to open the file ("w", "r", "a", ...)
+        # @yield [file] code to run on the file
+        # @yieldparam [File] file the opened file
+        def open_file(file, mode='w', &block)
+          open_up_file root, file, mode, &block
+        end
+    
+        ##
+        # This does the actual opening of a file.
+        # 
+        # @param [String] dir This dir is where the temp file is made, but ALSO
+        #   the parent dir of +file+
+        # @param [String] file Just the file name. It must exist at "#{dir}/#{file}"
+        def open_up_file(dir, file, mode, &block)
+          path = File.join dir, file
+          if mode == 'r' # if we're doing a read, make this super snappy
+            Kernel::open path, mode, &block
+          else # we're doing a write
+            File::amp_atomic_write path, mode, @create_mode, dir, &block
+          end
+        end
+      end
+    end
+  end
+end