change 0.1.0

data/.gitignore

@@ -0,0 +1,10 @@
+.DS_Store
+*.gem
+.bundle
+bin/murmur3
+ext/change/change
+ext/change/*.o
+Gemfile.lock
+pkg
+spec/tmp
+tmp

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2010
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+Change
+======
+
+What files changed since last time?
+
+With dependency management and super fast hashing ([Murmur3](https://github.com/PeterScott/murmur3)).
+
+[![Build Status](https://secure.travis-ci.org/winton/change.png)](http://travis-ci.org/winton/change)
+
+Requirements
+------------
+
+    gem install change
+
+Changed?
+--------
+
+    @change = Change.new("/absolute/path")
+    @change.d?("relative/path")
+    @change.d        # { :add => [], :mod => [], :rem => [] }
+    @change.d(true)  # reload
+
+`Change` uses a YAML file stored in the root directory called `.change.yml` to maintain state.
+
+Calling `@change.d?` does the following:
+
+* Check if there is an entry for path in `.change.yml`
+   * If yes, read file size and compare with entry
+      * If file size matches, compare Murmur hash
+   * If no, record file size and Murmur hash
+* Look up path in dependency tree
+   * If found, also mark all dependency parent paths as changed
+
+Dependencies
+------------
+
+To group dependencies, `Change` uses the concept of a "session":
+
+    @change = Change.new("/absolute/path")
+    @change.s(:some_id)         # start session with id
+    @change.r("relative/path")  # record dependency
+    @change.s(nil)              # stop session
+
+If you use `@change.d?` within a session, it will return true if any dependencies have changed. `Change` recalls the dependencies from the last session to achieve this.
+
+    @change.s(:some_id)
+    @change.d?('relative/path')
+      # returns true if any dependencies have changed
+      # dependencies are recalled from LAST :some_id session
+
+Recall files that were modified during the last execution of this session:
+
+    @change.s(:some_id)
+    @change.d_  # returns: { :add => [], :mod => [], :rem => [] }

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+task :default do
+  Dir.chdir("ext/change") do
+    system("make && make install")
+  end
+  Rake::Task['spec'].execute
+end

data/bin/change

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require File.expand_path("../../lib/change", __FILE__)

data/change.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+root = File.expand_path('../', __FILE__)
+lib = "#{root}/lib"
+
+$:.unshift lib unless $:.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name        = "change"
+  s.version     = '0.1.0'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = [ 'Winton Welsh' ]
+  s.email       = [ 'mail@wintoni.us' ]
+  s.homepage    = "http://github.com/winton/change"
+  s.summary     = %q{What files changed since last time?}
+  s.description = %q{What files changed since last time? With dependency management and super fast hashing (Murmur3).}
+
+  s.executables = `cd #{root} && git ls-files bin/*`.split("\n").collect { |f| File.basename(f) }
+  s.extensions = [ 'ext/change/extconf.rb' ]
+  s.files = `cd #{root} && git ls-files`.split("\n")
+  s.require_paths = %w(lib)
+  s.test_files = `cd #{root} && git ls-files -- {features,test,spec}/*`.split("\n")
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 1.0"
+end

data/ext/change/change.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include "murmur3.h"
+
+int main(int argc, char **argv) {
+  uint32_t hash[4];    /* Output for the hash */
+  uint32_t seed = 42;  /* Seed value for hash */
+
+  int x;
+
+  for (x = 1; x < argc; x++) {
+    FILE *fh = fopen(argv[x], "rb");
+
+    if (fh != NULL) {
+      fseek(fh, 0L, SEEK_END);
+      long s = ftell(fh);
+
+      char *buffer = malloc(s + 1);
+      buffer[s] = '\0';
+      
+      rewind(fh);
+
+      if (s != 0) {
+        fread(buffer, s, 1, fh);
+        fclose(fh);
+        fh = NULL;
+      }
+   
+      MurmurHash3_x86_32(buffer, strlen(buffer), seed, hash);
+      printf("%08u\n", hash[0]);
+ 
+      free(buffer);
+
+      if (fh != NULL)
+        fclose(fh);
+    }
+  }
+
+  return 0;
+}

data/ext/change/makefile

@@ -0,0 +1,8 @@
+CFLAGS = -O2 -Wall
+
+all: change
+change: change.o murmur3.o
+install:
+	rm *.o
+	mv -f change ../../bin/murmur3
+	chmod +x ../../bin/murmur3

data/ext/change/murmur3.c

@@ -0,0 +1,315 @@
+//-----------------------------------------------------------------------------
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+// Note - The x86 and x64 versions do _not_ produce the same results, as the
+// algorithms are optimized for their respective platforms. You can still
+// compile and run any of them on any platform, but your performance with the
+// non-native version will be less than optimal.
+
+#include "murmur3.h"
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+
+#ifdef __GNUC__
+#define FORCE_INLINE __attribute__((always_inline))
+#else
+#define FORCE_INLINE
+#endif
+
+static inline FORCE_INLINE uint32_t rotl32 ( uint32_t x, int8_t r )
+{
+  return (x << r) | (x >> (32 - r));
+}
+
+static inline FORCE_INLINE uint64_t rotl64 ( uint64_t x, int8_t r )
+{
+  return (x << r) | (x >> (64 - r));
+}
+
+#define	ROTL32(x,y)	rotl32(x,y)
+#define ROTL64(x,y)	rotl64(x,y)
+
+#define BIG_CONSTANT(x) (x##LLU)
+
+//-----------------------------------------------------------------------------
+// Block read - if your platform needs to do endian-swapping or can only
+// handle aligned reads, do the conversion here
+
+#define getblock(p, i) (p[i])
+
+//-----------------------------------------------------------------------------
+// Finalization mix - force all bits of a hash block to avalanche
+
+static inline FORCE_INLINE uint32_t fmix32 ( uint32_t h )
+{
+  h ^= h >> 16;
+  h *= 0x85ebca6b;
+  h ^= h >> 13;
+  h *= 0xc2b2ae35;
+  h ^= h >> 16;
+
+  return h;
+}
+
+//----------
+
+static inline FORCE_INLINE uint64_t fmix64 ( uint64_t k )
+{
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xff51afd7ed558ccd);
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
+  k ^= k >> 33;
+
+  return k;
+}
+
+//-----------------------------------------------------------------------------
+
+void MurmurHash3_x86_32 ( const void * key, int len,
+                          uint32_t seed, void * out )
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 4;
+  int i;
+
+  uint32_t h1 = seed;
+
+  uint32_t c1 = 0xcc9e2d51;
+  uint32_t c2 = 0x1b873593;
+
+  //----------
+  // body
+
+  const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
+
+  for(i = -nblocks; i; i++)
+  {
+    uint32_t k1 = getblock(blocks,i);
+
+    k1 *= c1;
+    k1 = ROTL32(k1,15);
+    k1 *= c2;
+    
+    h1 ^= k1;
+    h1 = ROTL32(h1,13); 
+    h1 = h1*5+0xe6546b64;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
+
+  uint32_t k1 = 0;
+
+  switch(len & 3)
+  {
+  case 3: k1 ^= tail[2] << 16;
+  case 2: k1 ^= tail[1] << 8;
+  case 1: k1 ^= tail[0];
+          k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= len;
+
+  h1 = fmix32(h1);
+
+  *(uint32_t*)out = h1;
+} 
+
+//-----------------------------------------------------------------------------
+
+void MurmurHash3_x86_128 ( const void * key, const int len,
+                           uint32_t seed, void * out )
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 16;
+  int i;
+
+  uint32_t h1 = seed;
+  uint32_t h2 = seed;
+  uint32_t h3 = seed;
+  uint32_t h4 = seed;
+
+  uint32_t c1 = 0x239b961b; 
+  uint32_t c2 = 0xab0e9789;
+  uint32_t c3 = 0x38b34ae5; 
+  uint32_t c4 = 0xa1e38b93;
+
+  //----------
+  // body
+
+  const uint32_t * blocks = (const uint32_t *)(data + nblocks*16);
+
+  for(i = -nblocks; i; i++)
+  {
+    uint32_t k1 = getblock(blocks,i*4+0);
+    uint32_t k2 = getblock(blocks,i*4+1);
+    uint32_t k3 = getblock(blocks,i*4+2);
+    uint32_t k4 = getblock(blocks,i*4+3);
+
+    k1 *= c1; k1  = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+
+    h1 = ROTL32(h1,19); h1 += h2; h1 = h1*5+0x561ccd1b;
+
+    k2 *= c2; k2  = ROTL32(k2,16); k2 *= c3; h2 ^= k2;
+
+    h2 = ROTL32(h2,17); h2 += h3; h2 = h2*5+0x0bcaa747;
+
+    k3 *= c3; k3  = ROTL32(k3,17); k3 *= c4; h3 ^= k3;
+
+    h3 = ROTL32(h3,15); h3 += h4; h3 = h3*5+0x96cd1c35;
+
+    k4 *= c4; k4  = ROTL32(k4,18); k4 *= c1; h4 ^= k4;
+
+    h4 = ROTL32(h4,13); h4 += h1; h4 = h4*5+0x32ac3b17;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
+
+  uint32_t k1 = 0;
+  uint32_t k2 = 0;
+  uint32_t k3 = 0;
+  uint32_t k4 = 0;
+
+  switch(len & 15)
+  {
+  case 15: k4 ^= tail[14] << 16;
+  case 14: k4 ^= tail[13] << 8;
+  case 13: k4 ^= tail[12] << 0;
+           k4 *= c4; k4  = ROTL32(k4,18); k4 *= c1; h4 ^= k4;
+
+  case 12: k3 ^= tail[11] << 24;
+  case 11: k3 ^= tail[10] << 16;
+  case 10: k3 ^= tail[ 9] << 8;
+  case  9: k3 ^= tail[ 8] << 0;
+           k3 *= c3; k3  = ROTL32(k3,17); k3 *= c4; h3 ^= k3;
+
+  case  8: k2 ^= tail[ 7] << 24;
+  case  7: k2 ^= tail[ 6] << 16;
+  case  6: k2 ^= tail[ 5] << 8;
+  case  5: k2 ^= tail[ 4] << 0;
+           k2 *= c2; k2  = ROTL32(k2,16); k2 *= c3; h2 ^= k2;
+
+  case  4: k1 ^= tail[ 3] << 24;
+  case  3: k1 ^= tail[ 2] << 16;
+  case  2: k1 ^= tail[ 1] << 8;
+  case  1: k1 ^= tail[ 0] << 0;
+           k1 *= c1; k1  = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len;
+
+  h1 += h2; h1 += h3; h1 += h4;
+  h2 += h1; h3 += h1; h4 += h1;
+
+  h1 = fmix32(h1);
+  h2 = fmix32(h2);
+  h3 = fmix32(h3);
+  h4 = fmix32(h4);
+
+  h1 += h2; h1 += h3; h1 += h4;
+  h2 += h1; h3 += h1; h4 += h1;
+
+  ((uint32_t*)out)[0] = h1;
+  ((uint32_t*)out)[1] = h2;
+  ((uint32_t*)out)[2] = h3;
+  ((uint32_t*)out)[3] = h4;
+}
+
+//-----------------------------------------------------------------------------
+
+void MurmurHash3_x64_128 ( const void * key, const int len,
+                           const uint32_t seed, void * out )
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 16;
+  int i;
+
+  uint64_t h1 = seed;
+  uint64_t h2 = seed;
+
+  uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
+  uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
+
+  //----------
+  // body
+
+  const uint64_t * blocks = (const uint64_t *)(data);
+
+  for(i = 0; i < nblocks; i++)
+  {
+    uint64_t k1 = getblock(blocks,i*2+0);
+    uint64_t k2 = getblock(blocks,i*2+1);
+
+    k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+
+    h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729;
+
+    k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
+
+    h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
+
+  uint64_t k1 = 0;
+  uint64_t k2 = 0;
+
+  switch(len & 15)
+  {
+  case 15: k2 ^= (uint64_t)(tail[14]) << 48;
+  case 14: k2 ^= (uint64_t)(tail[13]) << 40;
+  case 13: k2 ^= (uint64_t)(tail[12]) << 32;
+  case 12: k2 ^= (uint64_t)(tail[11]) << 24;
+  case 11: k2 ^= (uint64_t)(tail[10]) << 16;
+  case 10: k2 ^= (uint64_t)(tail[ 9]) << 8;
+  case  9: k2 ^= (uint64_t)(tail[ 8]) << 0;
+           k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
+
+  case  8: k1 ^= (uint64_t)(tail[ 7]) << 56;
+  case  7: k1 ^= (uint64_t)(tail[ 6]) << 48;
+  case  6: k1 ^= (uint64_t)(tail[ 5]) << 40;
+  case  5: k1 ^= (uint64_t)(tail[ 4]) << 32;
+  case  4: k1 ^= (uint64_t)(tail[ 3]) << 24;
+  case  3: k1 ^= (uint64_t)(tail[ 2]) << 16;
+  case  2: k1 ^= (uint64_t)(tail[ 1]) << 8;
+  case  1: k1 ^= (uint64_t)(tail[ 0]) << 0;
+           k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= len; h2 ^= len;
+
+  h1 += h2;
+  h2 += h1;
+
+  h1 = fmix64(h1);
+  h2 = fmix64(h2);
+
+  h1 += h2;
+  h2 += h1;
+
+  ((uint64_t*)out)[0] = h1;
+  ((uint64_t*)out)[1] = h2;
+}
+
+//-----------------------------------------------------------------------------
+

data/ext/change/murmur3.h

@@ -0,0 +1,21 @@
+//-----------------------------------------------------------------------------
+// MurmurHash3 was written by Austin Appleby, and is placed in the
+// public domain. The author hereby disclaims copyright to this source
+// code.
+
+#ifndef _MURMURHASH3_H_
+#define _MURMURHASH3_H_
+
+#include <stdint.h>
+
+//-----------------------------------------------------------------------------
+
+void MurmurHash3_x86_32 (const void *key, int len, uint32_t seed, void *out);
+
+void MurmurHash3_x86_128(const void *key, int len, uint32_t seed, void *out);
+
+void MurmurHash3_x64_128(const void *key, int len, uint32_t seed, void *out);
+
+//-----------------------------------------------------------------------------
+
+#endif // _MURMURHASH3_H_

data/lib/change.rb

@@ -0,0 +1,114 @@
+require 'yaml'
+
+$:.unshift File.dirname(__FILE__)
+
+class Change
+
+  def initialize(root)
+    @root = File.expand_path(root)
+  end
+
+  def d?(path)
+    changed = @d.values.flatten
+    if @session && @last_deps && @last_deps.include?(path)
+      @last_deps.any? { |p| changed.include?(p) }
+    else
+      changed.include?(path)
+    end
+  end
+
+  def d(reload=false)
+    if @d && !reload
+      @d
+    else
+      paths = Dir.chdir(@root) { Dir["**/*"] }
+      add = paths - states.keys
+      rem = states.keys - paths
+      hashes = murmur_hashes(paths)
+
+      mod = paths.inject([]) do |array, path|
+        hash = hashes[path]
+        size = Dir.chdir(@root) { File.size(path) }
+        
+        if states[path] && size != states[path][:size]
+          array << path
+        elsif states[path] && hash != states[path][:hash]
+          array << path
+        end
+
+        states[path] ||= {}
+        states[path][:hash] = hash
+        states[path][:size] = size
+        
+        array
+      end
+
+      mod -= add
+      rem.each { |path| states.delete(path) }
+
+      write!
+
+      @d = { :add => add, :mod => mod, :rem => rem }
+    end
+  end
+
+  def d_
+    @last_session
+  end
+
+  def r(path)
+    if @session
+      deps[@session].push(path)
+      deps[@session].uniq!
+      write!
+    end
+  end
+
+  def s(id)
+    d(true)
+
+    if @session && @session != id
+      @last_session = sessions[@session] = d
+      write!
+    end
+
+    @session = id
+    @last_deps = @session ? deps[@session] : nil
+    deps[@session] = [] if @session
+  end
+
+  private
+
+  def data
+    @data ||= (YAML.load(File.read("#{@root}/.change.yml")) rescue {})
+  end
+
+  def murmur_bin
+    @murmur ||= File.expand_path('../../bin/murmur3', __FILE__)
+  end
+
+  def murmur_hashes(paths)
+    hashes = Dir.chdir(@root) do
+      `#{murmur_bin} #{paths.collect { |m| "'#{m}'" }.join(' ')}`
+    end
+    Hash[paths.zip(hashes.split("\n"))]
+  end
+
+  def deps
+    data['deps'] ||= {}
+  end
+
+  def sessions
+    data['sessions'] ||= {}
+  end
+
+  def states
+    data['states'] ||= {}
+  end
+
+  def write!
+    File.open("#{@root}/.change.yml", 'w') do |f|
+      f.write(YAML.dump(data))
+    end
+  end
+end

data/spec/change_spec.rb

@@ -0,0 +1,115 @@
+require 'fileutils'
+require 'spec_helper'
+
+describe ::Change do
+
+  before :all do
+    @root = File.expand_path('../../', __FILE__)
+    FileUtils.rm_rf(@tmp = "#{@root}/spec/tmp")
+    FileUtils.cp_r("#{@root}/spec/fixture", @tmp)
+    @change = ::Change.new(@tmp)
+  end
+
+  describe :d do
+    it "should return all files as added" do
+      @change.d.should == {
+        :add => [ "modify.txt", "remove.txt" ],
+        :mod => [],
+        :rem => []
+      }
+    end
+
+    it "should cache last changes" do
+      @change.d.should == {
+        :add => [ "modify.txt", "remove.txt" ],
+        :mod => [],
+        :rem => []
+      }
+    end
+
+    it "should return no files modified" do
+      @change.d(true).should == {
+        :add => [],
+        :mod => [],
+        :rem => []
+      }
+    end
+
+    it "should return modified" do
+      File.open("#{@tmp}/modify.txt", 'w') { |f| f.write('!') }
+      @change.d(true).should == {
+        :add => [],
+        :mod => [ "modify.txt" ],
+        :rem => []
+      }
+    end
+
+    it "should return removed" do
+      FileUtils.rm("#{@tmp}/remove.txt")
+      @change.d(true).should == {
+        :add => [],
+        :mod => [],
+        :rem => [ "remove.txt" ]
+      }
+    end
+
+    it "should return added" do
+      File.open("#{@tmp}/add.txt", 'w') { |f| f.write('!') }
+      @change.d(true).should == {
+        :add => [ "add.txt" ],
+        :mod => [],
+        :rem => []
+      }
+    end
+
+    it "should save state" do
+      @change = ::Change.new(@tmp)
+      @change.d.should == {
+        :add => [],
+        :mod => [],
+        :rem => []
+      }
+    end
+  end
+
+  describe :d? do
+    it "should return changed boolean" do
+      File.open("#{@tmp}/modify.txt", 'w') { |f| f.write('!!') }
+      @change.d(true)
+      @change.d?('add.txt').should == false
+      @change.d?('modify.txt').should == true
+    end
+  end
+
+  describe :s do
+    before :all do
+      @change.s(:id)
+      @change.r('modify.txt')
+      @change.r('remove.txt')
+      File.open("#{@tmp}/add.txt", 'w') { |f| f.write('!') }
+      File.open("#{@tmp}/modify.txt", 'w') { |f| f.write('!!!') }
+      @change.s(nil)
+    end
+
+    it "should record dependencies" do
+      @change.send(:deps).should == { :id => [ "modify.txt", "remove.txt" ] }
+    end
+
+    it "should record files modified during session" do
+      @change.send(:sessions).should == {
+        :id => {
+          :add => [ "add.txt" ], :mod => [ "modify.txt" ], :rem => []
+        }
+      }
+    end
+
+    it "should return proper data within next session" do
+      File.open("#{@tmp}/modify.txt", 'w') { |f| f.write('!!!!') }
+      @change.s(:id)
+      @change.d?("remove.txt").should == true
+      @change.d.should == { :add => [], :mod => [ "modify.txt" ], :rem => [] }
+      @change.d_.should == { :add => [ "add.txt" ], :mod => [ "modify.txt" ], :rem => [] }
+      @change.s(nil)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "pp"
+require "bundler"
+
+Bundler.require(:development)
+
+$root = File.expand_path('../../', __FILE__)
+
+require "#{$root}/lib/change"

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: change
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Winton Welsh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :development
+  version_requirements: *id002
+description: What files changed since last time? With dependency management and super fast hashing (Murmur3).
+email: 
+- mail@wintoni.us
+executables: 
+- change
+extensions: 
+- ext/change/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/change
+- change.gemspec
+- ext/change/change.c
+- ext/change/extconf.rb
+- ext/change/makefile
+- ext/change/murmur3.c
+- ext/change/murmur3.h
+- lib/change.rb
+- spec/change_spec.rb
+- spec/fixture/modify.txt
+- spec/fixture/remove.txt
+- spec/spec_helper.rb
+homepage: http://github.com/winton/change
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: What files changed since last time?
+test_files: 
+- spec/change_spec.rb
+- spec/fixture/modify.txt
+- spec/fixture/remove.txt
+- spec/spec_helper.rb