rip 0.0.1

data/lib/rip/memoize.rb

@@ -0,0 +1,111 @@
+# you know, for kids
+module Rip
+  module Memoize
+    def self.included(base)
+      base.extend self
+    end
+
+    def memoize(method)
+      @memoized ||= {}
+      @memoized[method] = true
+    end
+
+    def method_added(method)
+      @memoized ||= {}
+      return unless @memoized.delete(method)
+
+      real_name = "__memoized_#{method}"
+      alias_method real_name, method
+
+      if self.instance_method(method).arity == 0
+        define_method method do
+          if instance_variable_defined? ivar = "@#{method}"
+            instance_variable_get ivar
+          else
+            instance_variable_set ivar, send(real_name)
+          end
+        end
+      else
+        define_method method do |*args|
+          @memoize_cache ||= {}
+          key = [method, args].hash
+
+          if @memoize_cache.has_key?(key)
+            @memoize_cache[key]
+          else
+            @memoize_cache[key] = send(real_name, *args)
+          end
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'test/unit'
+
+  class TestMemoize < Test::Unit::TestCase
+    class Encoder
+      include Rip::Memoize
+
+      attr_reader :encodes
+      def initialize
+        @encodes = 0
+      end
+
+      memoize :encode
+      def encode(name)
+        @encodes += 1
+
+        parts = name.split(//).map do |letter|
+          letter[0]
+        end
+
+        parts.join('/')
+      end
+
+      memoize :simple
+      def simple
+        @encodes += 1
+        1 + 1
+      end
+    end
+
+    def setup
+      @obj = Encoder.new
+    end
+
+    def test_properly_executes_methods
+      @obj.encode('chris')
+      assert_equal '99/104/114/105/115', @obj.encode('chris')
+    end
+
+    def test_memoizes_method
+      @obj.encode('chris')
+      @obj.encode('chris')
+      @obj.encode('chris')
+
+      assert_equal 1, @obj.encodes
+    end
+
+    def test_memoizes_multiple_methods
+      @obj.encode('chris')
+      @obj.encode('bob')
+      @obj.encode('chris')
+      @obj.encode('bob')
+
+      assert_equal 2, @obj.encodes
+    end
+
+    def test_memoizes_argless_methods
+      @obj.simple
+      @obj.simple
+      assert_equal 1, @obj.encodes
+    end
+
+    def test_uses_simple_ivar_for_argless_methods
+      @obj.simple
+      assert_equal 2, @obj.instance_variable_get(:@simple)
+    end
+  end
+end

data/lib/rip/package.rb

@@ -0,0 +1,126 @@
+require 'digest/md5'
+
+#
+# Want to write your own package?
+#
+# Check Rip::PackageAPI for the methods you need.
+#
+
+module Rip
+  class Package
+    include PackageAPI, Memoize
+
+    attr_reader :source
+    def initialize(source, version = nil, files = nil)
+      @source = source.strip.chomp
+      @version = version
+      @files = files
+    end
+
+    @@patterns = {}
+    @@blocks = {}
+
+    def self.handles(*patterns, &block)
+      patterns.each do |pattern|
+        @@patterns[pattern] = self
+      end
+
+      @@blocks[self] = block if block
+    end
+
+    def self.for(source, *args)
+      source = source.strip.chomp
+
+      handler = @@patterns.detect do |pattern, klass|
+        case pattern
+        when String
+          if pattern[0,1] == '.'
+            pattern = Regexp.escape(pattern)
+            source.match Regexp.new("#{pattern}$")
+          else
+            source.include? pattern
+          end
+        else
+          source.match(pattern)
+        end
+      end
+
+      return handler[1].new(source, *args) if handler
+
+      handler = @@blocks.detect do |klass, block|
+        block.call(source)
+      end
+
+      return handler[0].new(source, *args) if handler
+    end
+
+    def to_s
+      "#{name} (#{version})"
+    end
+
+    memoize :cache_name
+    def cache_name
+      name + '-' + Digest::MD5.hexdigest(@source)
+    end
+
+    memoize :cache_path
+    def cache_path
+      File.join(packages_path, cache_name)
+    end
+
+    memoize :packages_path
+    def packages_path
+      File.join(Rip.dir, 'rip-packages')
+    end
+
+    def installed?
+      graph = PackageManager.new
+      graph.installed?(name) && graph.package_version(name) == version
+    end
+
+    def fetch
+      return if @fetched
+      fetch!
+      @fetched = true
+    end
+
+    def unpack
+      return if @unpacked
+      unpack!
+      @unpacked = true
+    end
+
+    def files
+      @files ||= files!
+    end
+
+    def files!
+      fetch
+      unpack
+
+      Dir.chdir cache_path do
+        Dir['lib/**/*'] + Dir['bin/**/*']
+      end
+    end
+    attr_writer :files
+
+    def dependencies
+      @dependencies ||= dependencies!
+    end
+
+    def dependencies!
+      if File.exists? deps = File.join(cache_path, 'deps.rip')
+        File.readlines(deps).map do |line|
+          source, version, *extra = line.split(' ')
+          Package.for(source, version)
+        end
+      else
+        []
+      end
+    end
+
+    def ui
+      Rip.ui
+    end
+  end
+end

data/lib/rip/package_api.rb

@@ -0,0 +1,94 @@
+#
+# When writing your own package, you'll want to override the
+# methods provided by PackageAPI.
+#
+# The following Package methods may also be of interested to
+# you:
+#
+#   source     - The path, URL, or name of the package's source
+#   cache_name - The name of the package's cache directory
+#   cache_path - The path to the package's cache directory
+#
+# You'll also want your package to listen for certain patterns
+# in sources.
+#
+# For example, a GitPackage is needed when the source begins with
+# "git://". To hook this up, we'd add the following to
+# Rip::GitPackage:
+#
+#   class Rip::GitPackage
+#     handles "git://"
+#   end
+#
+# The `handles` method can accept multiple parameters and
+# regular expressions.
+#
+# It also accepts a block, which will be passed the source.
+# If the block evaluates to true then that package type is used.
+#
+# For example:
+#
+#   class Rip::LocalGitPackage
+#     handles do |source|
+#       File.exists? File.join(source, '.git')
+#     end
+#   end
+#
+
+module Rip
+  module PackageAPI
+    # The package's name
+    def name
+      source
+    end
+
+    # We weren't given a specific version, so figure
+    # out what the latest version is and return it
+    def version
+      "0.0.1"
+    end
+
+    # Does this package's source exist?
+    def exists?
+      true
+    end
+
+    # Grab the package and stick it in our local cache,
+    # if it's not already there.
+    def fetch!
+      ui.puts "fetching #{name}..."
+    end
+
+    # Unpack the package we want into the cache.
+    def unpack!
+      ui.puts "unpacking #{self}..."
+    end
+
+    #
+    # The following are more obscure hooks, not usually needed
+    # for authoring a package.
+    #
+
+    # Does this package simply install other packages?
+    # Usually not.
+    def meta_package?
+      false
+    end
+
+    # Should this package be cached in rip-packages?
+    # Usually so.
+    def cached?
+      true
+    end
+
+    # A list of installed files. Usually handled by Package
+    def files!
+      []
+    end
+
+    # Packages we depend on. Usually handled by Package.
+    def dependencies!
+      []
+    end
+  end
+end

data/lib/rip/package_manager.rb

@@ -0,0 +1,175 @@
+require 'zlib'
+require 'set'
+
+module Rip
+  class VersionConflict < RuntimeError
+    def initialize(name, bad_version, requester, real_version, owners)
+      @name = name
+      @bad_version = bad_version
+      @requester = requester
+      @real_version = real_version
+      @owners = owners
+    end
+
+    def message
+      message = []
+      message << "version conflict!"
+      message << "#{@name} requested at #{@bad_version} by #{@requester}"
+
+      if @owners.size == 1
+        owners = @owners[0]
+      elsif @owners.size == 2
+        owners = "#{@owners[0]} and #{@owners[1]}"
+      else
+        owners = [ @owners[0...-1], "and #{@owners[-1]}" ].join(', ')
+      end
+
+      message << "#{@name} previously requested at #{@real_version} by #{owners}"
+      message.join("\n")
+    end
+    alias_method :to_s, :message
+  end
+
+  class PackageManager
+    attr_reader :dependencies, :dependents, :sources, :versions, :env
+
+    def initialize(env = nil)
+      @env = env || Rip::Env.active
+      load
+
+      # key is the package name, value is the current
+      # installed version
+      @versions ||= {}
+
+      # key is the package name, value is an array of
+      # libraries it depend on
+      @dependents ||= {}
+
+      # key is the package name, value is an array of
+      # libraries that depend on it
+      @dependencies ||= {}
+
+      # key is the package name, value is the source
+      @sources ||= {}
+
+      # key is the package name, value is the installed
+      # files
+      @files ||= {}
+    end
+
+    def inspect
+      "(#{self.class} dependencies=#{dependencies.inspect} dependents=#{dependents.inspect} sources=#{sources.inspect} versions=#{versions.inspect})"
+    end
+
+    def packages
+      @versions.keys.map { |name| package(name) }
+    end
+
+    def package_names
+      @versions.keys
+    end
+
+    def package(name)
+      return unless @versions[name]
+      Package.for(@sources[name], @versions[name], @files[name])
+    end
+
+    def packages_that_depend_on(name)
+      (@dependents[name] || []).map { |name| package(name) }
+    end
+
+    def files(name)
+      Array(@files[name])
+    end
+
+    def installed?(name)
+      @versions.has_key? name
+    end
+
+    def package_version(name)
+      @versions[name]
+    end
+
+    def add_package(package, parent = nil)
+      name = package.name
+      version = package.version
+
+      if @versions.has_key?(name) && @versions[name] != version
+        raise VersionConflict.new(name, version, parent, @versions[name], @dependents[name].to_a)
+      end
+
+      if parent && !parent.meta_package?
+        @dependents[name] ||= Set.new
+        @dependents[name].add(parent.name)
+        @dependencies[parent.name] ||= Set.new
+        @dependencies[parent.name].add(name)
+      end
+
+      # already installed?
+      if @versions.has_key? name
+        false
+      else
+        @versions[name] = version
+        @sources[name] = package.source
+        @files[name] = package.files
+        true
+      end
+    ensure
+      save
+    end
+
+    def add_files(name, file_list = [])
+      @files[name] ||= []
+      @files[name].concat file_list
+      save
+    end
+
+    def remove_package(package)
+      name = package.name
+
+      Array(@dependencies[name]).each do |dep|
+        @dependents[dep].delete(name) if @dependents[dep].respond_to? :delete
+      end
+
+      @dependents.delete(name)
+      @dependencies.delete(name)
+      @versions.delete(name)
+      save
+    end
+
+    def path
+      File.join(dir, "#{@env}.ripenv")
+    end
+
+    def dir
+      File.join(Rip.dir, @env)
+    end
+
+    def save
+      File.open(path, 'w') do |f|
+        f.puts zip(marshal_payload)
+        f.flush
+      end
+    end
+
+    def load
+      marshal_read unzip(File.read(path)) if File.exists? path
+    end
+
+    def zip(data)
+      Zlib::Deflate.deflate(data)
+    end
+
+    def unzip(data)
+      Zlib::Inflate.inflate(data)
+    end
+
+    def marshal_payload
+      Marshal.dump [ @versions, @dependents, @dependencies, @sources, @files ]
+    end
+
+    def marshal_read(data)
+      @versions, @dependents, @dependencies, @sources, @files = Marshal.load(data)
+    end
+  end
+end