middleman-core 3.0.0.alpha.9 → 3.0.0.beta.1

data/lib/middleman-core/vendor/darwin/.gitignore

@@ -0,0 +1,18 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+
+## MAC OS
+.DS_Store
+.Trashes
+.com.apple.timemachine.supported
+.fseventsd
+Desktop DB
+Desktop DF
+/bin/fsevent_watch
+/ext/Makefile
+
+## editor/IDE
+.idea
+

data/lib/middleman-core/vendor/darwin/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "rake"
+

data/lib/middleman-core/vendor/darwin/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at http://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r(^spec/(.*)_spec.rb))
+  watch(%r(^lib/(.*)\.rb))        { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')    { "spec" }
+end

data/lib/middleman-core/vendor/darwin/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+namespace(:spec) do
+  desc "Run all specs on multiple ruby versions (requires rvm)"
+  task(:portability) do
+    %w[1.8.6 1.8.7 1.9.2 jruby-head].each do |version|
+      system <<-BASH
+        bash -c 'source ~/.rvm/scripts/rvm;
+                 rvm #{version};
+                 echo "--------- version #{version} ----------\n";
+                 bundle install;
+                 rake spec'
+      BASH
+    end
+  end
+end

data/lib/middleman-core/vendor/darwin/ext/fsevent/fsevent_watch.c

@@ -0,0 +1,226 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <CoreServices/CoreServices.h>
+
+
+// Structure for storing metadata parsed from the commandline
+static struct {
+  FSEventStreamEventId        sinceWhen;
+  CFTimeInterval              latency;
+  FSEventStreamCreateFlags    flags;
+  CFMutableArrayRef           paths;
+} config = {
+  (UInt64) kFSEventStreamEventIdSinceNow,
+  (double) 0.3,
+  (UInt32) kFSEventStreamCreateFlagNone,
+  NULL
+};
+
+// Prototypes
+static void         append_path(const char *path);
+static inline void  parse_cli_settings(int argc, const char *argv[]);
+static void         callback(FSEventStreamRef streamRef,
+                             void *clientCallBackInfo,
+                             size_t numEvents,
+                             void *eventPaths,
+                             const FSEventStreamEventFlags eventFlags[],
+                             const FSEventStreamEventId eventIds[]);
+
+
+// Resolve a path and append it to the CLI settings structure
+// The FSEvents API will, internally, resolve paths using a similar scheme.
+// Performing this ahead of time makes things less confusing, IMHO.
+static void append_path(const char *path)
+{
+#ifdef DEBUG
+  fprintf(stderr, "\n");
+  fprintf(stderr, "append_path called for: %s\n", path);
+#endif
+
+  char fullPath[PATH_MAX];
+
+  if (realpath(path, fullPath) == NULL) {
+#ifdef DEBUG
+    fprintf(stderr, "  realpath not directly resolvable from path\n");
+#endif
+
+    if (path[0] != '/') {
+#ifdef DEBUG
+      fprintf(stderr, "  passed path is not absolute\n");
+#endif
+      size_t len;
+      getcwd(fullPath, sizeof(fullPath));
+#ifdef DEBUG
+      fprintf(stderr, "  result of getcwd: %s\n", fullPath);
+#endif
+      len = strlen(fullPath);
+      fullPath[len] = '/';
+      strlcpy(&fullPath[len + 1], path, sizeof(fullPath) - (len + 1));
+    } else {
+#ifdef DEBUG
+      fprintf(stderr, "  assuming path does not YET exist\n");
+#endif
+      strlcpy(fullPath, path, sizeof(fullPath));
+    }
+  }
+
+#ifdef DEBUG
+  fprintf(stderr, "  resolved path to: %s\n", fullPath);
+  fprintf(stderr, "\n");
+  fflush(stderr);
+#endif
+
+  CFStringRef pathRef = CFStringCreateWithCString(kCFAllocatorDefault,
+                                                  fullPath,
+                                                  kCFStringEncodingUTF8);
+  CFArrayAppendValue(config.paths, pathRef);
+  CFRelease(pathRef);
+}
+
+// Parse commandline settings
+static inline void parse_cli_settings(int argc, const char *argv[])
+{
+  config.paths = CFArrayCreateMutable(NULL,
+                                      (CFIndex)0,
+                                      &kCFTypeArrayCallBacks);
+
+  for (int i = 1; i < argc; i++) {
+    if (strcmp(argv[i], "--since-when") == 0) {
+      config.sinceWhen = strtoull(argv[++i], NULL, 0);
+    } else if (strcmp(argv[i], "--latency") == 0) {
+      config.latency = strtod(argv[++i], NULL);
+    } else if (strcmp(argv[i], "--no-defer") == 0) {
+      config.flags |= kFSEventStreamCreateFlagNoDefer;
+    } else if (strcmp(argv[i], "--watch-root") == 0) {
+      config.flags |= kFSEventStreamCreateFlagWatchRoot;
+    } else if (strcmp(argv[i], "--ignore-self") == 0) {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
+      config.flags |= kFSEventStreamCreateFlagIgnoreSelf;
+#else
+      fprintf(stderr, "MacOSX10.6.sdk is required for --ignore-self\n");
+#endif
+    } else {
+      append_path(argv[i]);
+    }
+  }
+
+  if (CFArrayGetCount(config.paths) == 0) {
+    append_path(".");
+  }
+
+#ifdef DEBUG
+  fprintf(stderr, "config.sinceWhen    %llu\n", config.sinceWhen);
+  fprintf(stderr, "config.latency      %f\n", config.latency);
+  fprintf(stderr, "config.flags        %#.8x\n", config.flags);
+  fprintf(stderr, "config.paths\n");
+
+  long numpaths = CFArrayGetCount(config.paths);
+
+  for (long i = 0; i < numpaths; i++) {
+    char path[PATH_MAX];
+    CFStringGetCString(CFArrayGetValueAtIndex(config.paths, i),
+                       path,
+                       PATH_MAX,
+                       kCFStringEncodingUTF8);
+    fprintf(stderr, "  %s\n", path);
+  }
+
+  fprintf(stderr, "\n");
+  fflush(stderr);
+#endif
+}
+
+static void callback(FSEventStreamRef streamRef,
+                     void *clientCallBackInfo,
+                     size_t numEvents,
+                     void *eventPaths,
+                     const FSEventStreamEventFlags eventFlags[],
+                     const FSEventStreamEventId eventIds[])
+{
+  char **paths = eventPaths;
+
+#ifdef DEBUG
+  fprintf(stderr, "\n");
+  fprintf(stderr, "FSEventStreamCallback fired!\n");
+  fprintf(stderr, "  numEvents: %lu\n", numEvents);
+
+  for (size_t i = 0; i < numEvents; i++) {
+    fprintf(stderr, "  event path: %s\n", paths[i]);
+    fprintf(stderr, "  event flags: %#.8x\n", eventFlags[i]);
+    fprintf(stderr, "  event ID: %llu\n", eventIds[i]);
+  }
+
+  fprintf(stderr, "\n");
+  fflush(stderr);
+#endif
+
+  for (size_t i = 0; i < numEvents; i++) {
+    fprintf(stdout, "%s", paths[i]);
+    fprintf(stdout, ":");
+  }
+
+  fprintf(stdout, "\n");
+  fflush(stdout);
+}
+
+int main(int argc, const char *argv[])
+{
+  /*
+   * a subprocess will initially inherit the process group of its parent. the
+   * process group may have a control terminal associated with it, which would
+   * be the first tty device opened by the group leader. typically the group
+   * leader is your shell and the control terminal is your login device. a
+   * subset of signals triggered on the control terminal are sent to all members
+   * of the process group, in large part to facilitate sane and consistent
+   * cleanup (ex: control terminal was closed).
+   *
+   * so why the overly descriptive lecture style comment?
+   *   1. SIGINT and SIGQUIT are among the signals with this behavior
+   *   2. a number of applications gank the above for their own use
+   *   3. ruby's insanely useful "guard" is one of these applications
+   *   4. despite having some level of understanding of POSIX signals and a few
+   *      of the scenarios that might cause problems, i learned this one only
+   *      after reading ruby 1.9's process.c
+   *   5. if left completely undocumented, even slightly obscure bugfixes
+   *      may be removed as cruft by a future maintainer
+   *
+   * hindsight is 20/20 addition: if you're single-threaded and blocking on IO
+   * with a subprocess, then handlers for deferrable signals might not get run
+   * when you expect them to. In the case of Ruby 1.8, that means making use of
+   * IO::select, which will preserve correct signal handling behavior.
+   */
+  if (setpgid(0,0) < 0) {
+    fprintf(stderr, "Unable to set new process group.\n");
+    return 1;
+  }
+
+  parse_cli_settings(argc, argv);
+
+  FSEventStreamContext context = {0, NULL, NULL, NULL, NULL};
+  FSEventStreamRef stream;
+  stream = FSEventStreamCreate(kCFAllocatorDefault,
+                               (FSEventStreamCallback)&callback,
+                               &context,
+                               config.paths,
+                               config.sinceWhen,
+                               config.latency,
+                               config.flags);
+
+#ifdef DEBUG
+  FSEventStreamShow(stream);
+  fprintf(stderr, "\n");
+  fflush(stderr);
+#endif
+
+  FSEventStreamScheduleWithRunLoop(stream,
+                                   CFRunLoopGetCurrent(),
+                                   kCFRunLoopDefaultMode);
+  FSEventStreamStart(stream);
+  CFRunLoopRun();
+  FSEventStreamFlushSync(stream);
+  FSEventStreamStop(stream);
+
+  return 0;
+}

data/lib/middleman-core/vendor/{rb-fsevent-0.4.3.1 → darwin}/lib/rb-fsevent/fsevent.rb

@@ -2,12 +2,12 @@ class FSEvent
   class << self
     class_eval <<-END
       def root_path
-        "#{File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))}"
+        "#{File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', '..', '..'))}"
       end
     END
     class_eval <<-END
       def watcher_path
-        "#{File.join(FSEvent.root_path, 'bin', 'fsevent_watch')}"
+        "#{File.join(FSEvent.root_path, 'bin', 'fsevent_watch_guard')}"
       end
     END
   end

data/lib/middleman-core/vendor/darwin/rb-fsevent.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rb-fsevent/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rb-fsevent"
+  s.version     = FSEvent::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Thibaud Guillaume-Gentil', 'Travis Tilley']
+  s.email       = ['thibaud@thibaud.me', 'ttilley@gmail.com']
+  s.homepage    = "http://rubygems.org/gems/rb-fsevent"
+  s.summary     = "Very simple & usable FSEvents API"
+  s.description = "FSEvents API with Signals catching (without RubyCocoa)"
+
+  s.rubyforge_project = "rb-fsevent"
+
+  s.add_development_dependency  'bundler',     '~> 1.0.10'
+  s.add_development_dependency  'rspec',       '~> 2.5.0'
+  s.add_development_dependency  'guard-rspec', '~> 0.1.9'
+
+  s.files        = Dir.glob('{lib,ext}/**/*') + %w[LICENSE README.rdoc]
+  s.extensions   = ['ext/extconf.rb']
+  s.require_path = 'lib'
+end

data/lib/middleman-core/vendor/darwin/spec/rb-fsevent/fsevent_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe FSEvent do
+
+  before(:each) do
+    @results = []
+    @fsevent = FSEvent.new
+    @fsevent.watch @fixture_path.to_s, {:latency => 0.5} do |paths|
+      @results += paths
+    end
+  end
+
+  it "should have a watcher_path that resolves to an executable file" do
+    File.exists?(FSEvent.watcher_path).should be_true
+    File.executable?(FSEvent.watcher_path).should be_true
+  end
+
+  it "should work with path with an apostrophe" do
+    custom_path = @fixture_path.join("custom 'path")
+    file = custom_path.join("newfile.rb").to_s
+    File.delete file if File.exists? file
+    @fsevent.watch custom_path.to_s do |paths|
+      @results += paths
+    end
+    @fsevent.paths.should == ["#{custom_path}"]
+    run
+    FileUtils.touch file
+    stop
+    File.delete file
+    @results.should == [custom_path.to_s + '/']
+  end
+
+  it "should catch new file" do
+    file = @fixture_path.join("newfile.rb")
+    File.delete file if File.exists? file
+    run
+    FileUtils.touch file
+    stop
+    File.delete file
+    @results.should == [@fixture_path.to_s + '/']
+  end
+
+  it "should catch file update" do
+    file = @fixture_path.join("folder1/file1.txt")
+    File.exists?(file).should be_true
+    run
+    FileUtils.touch file
+    stop
+    @results.should == [@fixture_path.join("folder1/").to_s]
+  end
+
+  it "should catch files update" do
+    file1 = @fixture_path.join("folder1/file1.txt")
+    file2 = @fixture_path.join("folder1/folder2/file2.txt")
+    File.exists?(file1).should be_true
+    File.exists?(file2).should be_true
+    run
+    FileUtils.touch file1
+    FileUtils.touch file2
+    stop
+    @results.should == [@fixture_path.join("folder1/").to_s, @fixture_path.join("folder1/folder2/").to_s]
+  end
+
+  def run
+    sleep 1
+    Thread.new { @fsevent.run }
+    sleep 1
+  end
+
+  def stop
+    sleep 1
+    @fsevent.stop
+  end
+
+end

data/lib/middleman-core/vendor/darwin/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'rspec'
+require 'rb-fsevent'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  
+  config.before(:each) do
+    @fixture_path = Pathname.new(File.expand_path('../fixtures/', __FILE__))
+  end
+  
+  config.before(:all) do
+    system "cd ext; ruby extconf.rb"
+    puts "fsevent_watch compiled"
+  end
+  
+  config.after(:all) do
+    gem_root = Pathname.new(File.expand_path('../../', __FILE__))
+    system "rm -rf #{gem_root.join('bin')}"
+    system "rm #{gem_root.join('ext/Makefile')}"
+  end
+  
+end

data/lib/middleman-core/vendor/linux/.gitignore

@@ -0,0 +1,3 @@
+/.yardoc
+/doc
+/pkg

data/lib/middleman-core/version.rb

@@ -4,7 +4,7 @@ require "rubygems"
 module Middleman
   # Current Version
   # @return [String]
-  VERSION = '3.0.0.alpha.9' unless const_defined?(:VERSION)
+  VERSION = '3.0.0.beta.1' unless const_defined?(:VERSION)
   
   # Parsed version for RubyGems
   # @private

data/lib/middleman-core/watcher.rb

@@ -1,9 +1,6 @@
 # Inspect Ruby env
 require "rbconfig"
 
-# Watcher Library
-require "fssm"
-
 # File changes are forwarded to the currently running app via HTTP
 require "net/http"
 
@@ -14,7 +11,7 @@ module Middleman
       
       def start(options)
         self.singleton = new(options)
-        self.singleton.watch!
+        self.singleton.watch! unless options[:"disable-watcher"]
       end
       
       # What command is sent to kill instances
@@ -36,11 +33,9 @@ module Middleman
       @options = options
 
       if RbConfig::CONFIG['target_os'] =~ /darwin/i
-        $LOAD_PATH << File.expand_path('../../middleman-core/vendor/rb-fsevent-0.4.3.1/lib', __FILE__)
-        require 'rb-fsevent'
+        $LOAD_PATH << File.expand_path('../../middleman-core/vendor/darwin/lib', __FILE__)
       elsif RbConfig::CONFIG['target_os'] =~ /linux/i
-        $LOAD_PATH << File.expand_path('../../middleman-core/vendor/rb-inotify-0.8.8/lib', __FILE__)
-        require 'rb-inotify'
+        $LOAD_PATH << File.expand_path('../../middleman-core/vendor/linux/lib', __FILE__)
       end
       
       start
@@ -48,6 +43,10 @@ module Middleman
     
     def watch!
       local = self
+
+      # Watcher Library
+      require "fssm"
+      
       FSSM.monitor(Dir.pwd) do
         create { |base, relative| local.run_on_change([relative]) }
         update { |base, relative| local.run_on_change([relative]) }
@@ -58,10 +57,14 @@ module Middleman
     # Start Middleman in a fork
     # @return [void]
     def start
-      @server_job = fork {
-        Signal.trap(::Middleman::WINDOWS ? :KILL : :TERM) { exit! }
+      if @options[:"disable-watcher"]
         bootup
-      }
+      else
+        @server_job = fork {
+          Signal.trap(::Middleman::WINDOWS ? :KILL : :TERM) { exit! }
+          bootup
+        }
+      end
     end
     
     # Start an instance of Middleman::Base
@@ -87,9 +90,11 @@ module Middleman
     # @return [void]
     def stop
       puts "== The Middleman is shutting down"
-      Process.kill(::Middleman::WINDOWS ? :KILL : :TERM, @server_job)
-      Process.wait @server_job
-      @server_job = nil
+      if !@options[:"disable-watcher"]
+        Process.kill(::Middleman::WINDOWS ? :KILL : :TERM, @server_job)
+        Process.wait @server_job
+        @server_job = nil
+      end
     end
     
     # Simply stop, then start

data/middleman-core.gemspec

@@ -13,10 +13,10 @@ Gem::Specification.new do |s|
   s.summary     = "Hand-crafted frontend development"
   s.description = "A static site generator based on Sinatra. Providing dozens of templating languages (Haml, Sass, Compass, Slim, CoffeeScript, and more). Makes minification, compression, cache busting, Yaml data (and more) an easy part of your development cycle."
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {fixtures,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.files        = `git ls-files`.split("\n") + %w(bin/fsevent_watch_guard)
+  s.test_files   = `git ls-files -- {fixtures,features}/*`.split("\n")
+  s.executable   = "middleman"
+  s.require_path = "lib"
 
   # Thin
   # s.add_dependency("thin", ["~> 1.3.1"])