middleman-core 3.0.0.beta.2 → 3.0.0.beta.3

data/lib/middleman-core/vendor/padrino-helpers-0.10.6/test/test_tag_helpers.rb

@@ -1,106 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/markup_app/app')
-
-describe "TagHelpers" do
-  def app
-    MarkupDemo.tap { |app| app.set :environment, :test }
-  end
-
-  context 'for #tag method' do
-    should("support tags with no content no attributes") do
-      assert_has_tag(:br) { tag(:br) }
-    end
-
-    should("support tags with no content with attributes") do
-      actual_html = tag(:br, :style => 'clear:both', :class => 'yellow')
-      assert_has_tag(:br, :class => 'yellow', :style=>'clear:both') { actual_html }
-    end
-
-    should "support selected attribute by using 'selected' if true" do
-      actual_html = tag(:option, :selected => true)
-      assert_has_tag('option', :selected => 'selected') { actual_html }
-    end
-
-    should "support data attributes" do
-      actual_html = tag(:a, :data => { :remote => true, :method => 'post'})
-      assert_has_tag(:a, 'data-remote' => 'true', 'data-method' => 'post') { actual_html }
-    end
-
-    should "support nested attributes" do
-      actual_html = tag(:div, :data => {:dojo => {:type => 'dijit.form.TextBox', :props => 'readOnly: true'}})
-      assert_has_tag(:div, 'data-dojo-type' => 'dijit.form.TextBox', 'data-dojo-props' => 'readOnly: true') { actual_html }
-    end
-
-    should "support open tags" do
-      actual_html = tag(:p, { :class => 'demo' }, true)
-      assert_equal "<p class=\"demo\">", actual_html
-    end
-
-    should "escape html" do
-      actual_html = tag(:br, :class => 'Example "bar"')
-      assert_equal "<br class=\"Example &quot;bar&quot;\" />", actual_html
-    end
-  end
-
-  context 'for #content_tag method' do
-    should "support tags with content as parameter" do
-      actual_html = content_tag(:p, "Demo", :class => 'large', :id => 'thing')
-      assert_has_tag('p.large#thing', :content => "Demo") { actual_html }
-    end
-
-    should "support tags with content as block" do
-      actual_html = content_tag(:p, :class => 'large', :id => 'star') { "Demo" }
-      assert_has_tag('p.large#star', :content => "Demo") { actual_html }
-    end
-
-    should "support tags with erb" do
-      visit '/erb/content_tag'
-      assert_have_selector :p, :content => "Test 1", :class => 'test', :id => 'test1'
-      assert_have_selector :p, :content => "Test 2"
-      assert_have_selector :p, :content => "Test 3"
-      assert_have_selector :p, :content => "Test 4"
-    end
-
-    should "support tags with haml" do
-      visit '/haml/content_tag'
-      assert_have_selector :p, :content => "Test 1", :class => 'test', :id => 'test1'
-      assert_have_selector :p, :content => "Test 2"
-      assert_have_selector :p, :content => "Test 3", :class => 'test', :id => 'test3'
-      assert_have_selector :p, :content => "Test 4"
-    end
-
-    should "support tags with slim" do
-      visit '/slim/content_tag'
-      assert_have_selector :p, :content => "Test 1", :class => 'test', :id => 'test1'
-      assert_have_selector :p, :content => "Test 2"
-      assert_have_selector :p, :content => "Test 3", :class => 'test', :id => 'test3'
-      assert_have_selector :p, :content => "Test 4"
-    end
-  end
-
-  context 'for #input_tag method' do
-    should "support field with type" do
-      assert_has_tag('input[type=text]') { input_tag(:text) }
-    end
-
-    should "support field with type and options" do
-      actual_html = input_tag(:text, :class => "first", :id => 'texter')
-      assert_has_tag('input.first#texter[type=text]') { actual_html }
-    end
-
-    should "support checked attribute by using 'checked' if true" do
-      actual_html = input_tag(:checkbox, :checked => true)
-      assert_has_tag('input[type=checkbox]', :checked => 'checked') { actual_html }
-    end
-
-    should "remove checked attribute if false" do
-      actual_html = input_tag(:checkbox, :checked => false)
-      assert_has_no_tag('input[type=checkbox][checked=false]') { actual_html }
-    end
-
-    should "support disabled attribute by using 'disabled' if true" do
-      actual_html = input_tag(:checkbox, :disabled => true)
-      assert_has_tag('input[type=checkbox]', :disabled => 'disabled') { actual_html }
-    end
-  end
-end

data/lib/middleman-core/watcher.rb

@@ -1,196 +0,0 @@
-# File changes are forwarded to the currently running app via HTTP
-require "net/http"
-
-module Middleman
-  WINDOWS = !!(RUBY_PLATFORM =~ /(mingw|bccwin|wince|mswin32)/i) unless const_defined?(:WINDOWS)
-end
-
-require "win32/process" if ::Middleman::WINDOWS
-
-require "fileutils"
-
-module Middleman
-  class Watcher
-    class << self
-      attr_accessor :singleton
-      
-      def start(options)
-        self.singleton = new(options)
-        self.singleton.watch! unless options[:"disable-watcher"]
-      end
-      
-      def ignore_list
-        [
-          /\.sass-cache\//,
-          /\.git/,
-          /\.DS_Store$/,
-          /build\//,
-          /\.rbenv-version$/,
-          /Gemfile$/,
-          /Gemfile\.lock$/,
-          /\.mm-pid/
-        ]
-      end
-    end
-    
-    def initialize(options)
-      @options = options
-      
-      register_signal_handlers
-      start
-    end
-    
-    # What command is sent to kill instances
-    # @return [Symbol, Fixnum]
-    def kill_command
-      ::Middleman::WINDOWS ? 1 : "TERM"
-    end
-    
-    def watch!
-      local = self
-
-      # Watcher Library
-      require "listen"
-      
-      Listen.to(Dir.pwd) do |modified, added, removed|
-        added_and_modified = modified + added
-        
-        if added_and_modified.length > 0
-          added_and_modified.map! { |p| p.sub(Dir.pwd, "").sub(/^\//, "") }
-          local.run_on_change(added_and_modified)
-        end
-        
-        if removed.length > 0
-          removed_relative = removed.map! { |p| p.sub(Dir.pwd, "").sub(/^\//, "") }
-          local.run_on_deletion(removed_relative) 
-        end
-      end
-    end
-    
-    def pid_name
-      ".mm-pid-#{@options[:port]||4567}"
-    end
-    
-    def kill_pid!
-      if File.exists?(pid_name)
-        current_pid = File.open(pid_name, 'rb') { |f| f.read }
-        begin
-          Process.kill(kill_command, current_pid.to_i)
-        rescue
-        ensure
-          FileUtils.rm(pid_name) if File.exists?(pid_name)
-        end
-      end
-    end
-    
-    # Start Middleman in a fork
-    # @return [void]
-    def start
-      if @options[:"disable-watcher"]
-        bootup
-      else
-        kill_pid!
-        
-        @server_job = fork {
-          # trap("INT")  { exit(0) }
-          # trap("TERM") { exit(0) }
-          # trap("QUIT") { exit(0) }
-          bootup
-        }
-        
-        File.open(pid_name, "w+") { |f| f.write(@server_job) }
-      end
-    end
-    
-    # Start an instance of Middleman::Application
-    # @return [void]
-    def bootup
-      env = (@options[:environment] || "development").to_sym
-      is_logging = @options.has_key?(:debug) && @options[:debug]
-      
-      app = ::Middleman.server.inst do
-        set :environment, env
-        set :logging, is_logging
-      end
-      
-      app_rack = app.class.to_rack_app
-      
-      opts = @options.dup
-      opts[:app] = app_rack
-      opts[:logging] = is_logging
-      puts "== The Middleman is standing watch on port #{opts[:port]||4567}"
-      ::Middleman.start_server(opts)
-    end
-    
-    # Stop the forked Middleman
-    # @return [void]
-    def stop
-      puts "== The Middleman is shutting down"
-      if !@options[:"disable-watcher"]
-        kill_pid!
-        # Process.kill(::Middleman::WINDOWS ? :KILL : :TERM, @server_job)
-        # Process.wait @server_job
-        # @server_job = nil
-      end
-    end
-    
-    # Simply stop, then start
-    # @return [void]
-    def reload
-      stop
-      start
-    end
-    
-    # What to do on file change
-    # @param [Array<String>] paths Array of paths that changed
-    # @return [void]
-    def run_on_change(paths)
-      # See if the changed file is config.rb or lib/*.rb
-      return reload if needs_to_reload?(paths)
-      
-      # Otherwise forward to Middleman
-      paths.each do |path|
-        tell_server(:change => path) unless self.class.ignore_list.any? { |r| path.match(r) }
-      end
-    end
-
-    # What to do on file deletion
-    # @param [Array<String>] paths Array of paths that were removed
-    # @return [void]
-    def run_on_deletion(paths)
-      # See if the changed file is config.rb or lib/*.rb
-      return reload if needs_to_reload?(paths)
-      
-      # Otherwise forward to Middleman
-      paths.each do |path|
-        tell_server(:delete => path) unless self.class.ignore_list.any? { |r| path.match(r) }
-      end
-    end
-    
-  private
-    # Trap the interupt signal and shut down FSSM (and thus the server) smoothly
-    def register_signal_handlers
-      trap("INT")  { stop; exit(0) }
-      trap("TERM") { stop }
-      trap("QUIT") { stop; exit(0) }
-    end
-  
-    # Whether the passed files are config.rb, lib/*.rb or helpers
-    # @param [Array<String>] paths Array of paths to check
-    # @return [Boolean] Whether the server needs to reload
-    def needs_to_reload?(paths)
-      return false # disable reloading for now
-      paths.any? do |path|
-        path.match(%{^config\.rb}) || path.match(%r{^lib/^[^\.](.*)\.rb$}) || path.match(%r{^helpers/^[^\.](.*)_helper\.rb$})
-      end
-    end
-  
-    # Send a message to the running server
-    # @param [Hash] params Keys to be hashed and sent to server
-    # @return [void]
-    def tell_server(params={})
-      uri = URI.parse("http://#{@options[:host]}:#{@options[:port]}/__middleman__")
-      Net::HTTP.post_form(uri, {}.merge(params))
-    end
-  end
-end