middleman-core-cj 3.3.4

data/lib/middleman-core/step_definitions.rb

@@ -0,0 +1,21 @@
+require 'aruba/cucumber'
+require 'aruba/jruby'
+require 'middleman-core/step_definitions/middleman_steps'
+require 'middleman-core/step_definitions/builder_steps'
+require 'middleman-core/step_definitions/server_steps'
+
+# Monkeypatch for windows support
+module ArubaMonkeypatch
+  def detect_ruby(cmd)
+    if cmd.start_with?('middleman ') && Gem.win_platform?
+      "#{current_ruby} #{Dir.pwd}/bin/#{cmd}"
+    else
+      cmd.sub(/^ruby(?= )/, current_ruby)
+    end
+  end
+end
+World(ArubaMonkeypatch)
+
+Before do
+  @aruba_timeout_seconds = RUBY_PLATFORM == 'java' ? 120 : 60
+end

data/lib/middleman-core/step_definitions/builder_steps.rb

@@ -0,0 +1,77 @@
+require 'fileutils'
+
+Before do
+  @modification_times = Hash.new
+end
+
+Given /^app "([^\"]*)" is using config "([^\"]*)"$/ do |path, config_name|
+  target = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
+  config_path = File.join(current_dir, "config-#{config_name}.rb")
+  config_dest = File.join(current_dir, 'config.rb')
+  FileUtils.cp(config_path, config_dest)
+end
+
+Given /^an empty app$/ do
+  step %Q{a directory named "empty_app"}
+  step %Q{I cd to "empty_app"}
+  ENV['MM_ROOT'] = nil
+end
+
+Given /^a fixture app "([^\"]*)"$/ do |path|
+  ENV['MM_ROOT'] = nil
+
+  # This step can be reentered from several places but we don't want
+  # to keep re-copying and re-cd-ing into ever-deeper directories
+  next if File.basename(current_dir) == path
+
+  step %Q{a directory named "#{path}"}
+
+  target_path = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
+  FileUtils.cp_r(target_path, current_dir)
+
+  step %Q{I cd to "#{path}"}
+end
+
+Given /^a built app at "([^\"]*)"$/ do |path|
+  step %Q{a fixture app "#{path}"}
+  step %Q{I run `middleman build`}
+end
+
+Given /^was successfully built$/ do
+  step %Q{a directory named "build" should exist}
+  step %Q{the exit status should be 0}
+end
+
+Given /^a successfully built app at "([^\"]*)"$/ do |path|
+  step %Q{a built app at "#{path}"}
+  step %Q{was successfully built}
+end
+
+Given /^a built app at "([^\"]*)" with flags "([^\"]*)"$/ do |path, flags|
+  step %Q{a fixture app "#{path}"}
+  step %Q{I run `middleman build #{flags}`}
+end
+
+Given /^a successfully built app at "([^\"]*)" with flags "([^\"]*)"$/ do |path, flags|
+  step %Q{a built app at "#{path}" with flags "#{flags}"}
+  step %Q{was successfully built}
+end
+
+Given /^a modification time for a file named "([^\"]*)"$/ do |file|
+  target = File.join(current_dir, file)
+  @modification_times[target] = File.mtime(target)
+end
+
+Then /^the file "([^\"]*)" should not have been updated$/ do |file|
+  target = File.join(current_dir, file)
+  File.mtime(target).should == @modification_times[target]
+end
+
+# Provide this Aruba overload in case we're matching something with quotes in it
+Then /^the file "([^"]*)" should contain '([^']*)'$/ do |file, partial_content|
+  check_file_content(file, partial_content, true)
+end
+
+And /the file "(.*)" should be gzipped/ do |file|
+  expect(File.binread(File.join(current_dir, file), 2)).to eq(['1F8B'].pack('H*'))
+end

data/lib/middleman-core/step_definitions/middleman_steps.rb

@@ -0,0 +1,17 @@
+Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
+  write_file(path, contents)
+  step %Q{the file "#{path}" did change}
+end
+
+Then /^the file "([^\"]*)" is removed$/ do |path|
+  step %Q{I remove the file "#{path}"}
+  step %Q{the file "#{path}" did delete}
+end
+
+Then /^the file "([^\"]*)" did change$/ do |path|
+  @server_inst.files.did_change(path)
+end
+
+Then /^the file "([^\"]*)" did delete$/ do |path|
+  @server_inst.files.did_delete(path)
+end

data/lib/middleman-core/step_definitions/server_steps.rb

@@ -0,0 +1,104 @@
+# encoding: UTF-8
+
+require 'rack/test'
+
+Given /^a clean server$/ do
+  @initialize_commands = []
+end
+
+Given /^"([^\"]*)" feature is "([^\"]*)"$/ do |feature, state|
+  @initialize_commands ||= []
+
+  if state == 'enabled'
+    @initialize_commands << lambda { activate(feature.to_sym) }
+  end
+end
+
+Given /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_str|
+  @initialize_commands ||= []
+
+  options = eval("{#{options_str}}")
+
+  @initialize_commands << lambda { activate(feature.to_sym, options) }
+end
+
+Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
+  @initialize_commands ||= []
+  @initialize_commands << lambda { set(variable.to_sym, value) }
+end
+
+Given /^current environment is "([^\"]*)"$/ do |env|
+  @current_env = env.to_sym
+end
+
+Given /^the Server is running$/ do
+  root_dir = File.expand_path(current_dir)
+
+  if File.exists?(File.join(root_dir, 'source'))
+    ENV['MM_SOURCE'] = 'source'
+  else
+    ENV['MM_SOURCE'] = ''
+  end
+
+  ENV['MM_ROOT'] = root_dir
+
+  initialize_commands = @initialize_commands || []
+  initialize_commands.unshift lambda {
+    set :environment, @current_env || :development
+    set :show_exceptions, false
+  }
+
+  @server_inst = Middleman::Application.server.inst do
+    initialize_commands.each do |p|
+      instance_exec(&p)
+    end
+  end
+
+  app_rack = @server_inst.class.to_rack_app
+  @browser = ::Rack::Test::Session.new(::Rack::MockSession.new(app_rack))
+end
+
+Given /^the Server is running at "([^\"]*)"$/ do |app_path|
+  step %Q{a fixture app "#{app_path}"}
+  step %Q{the Server is running}
+end
+
+When /^I go to "([^\"]*)"$/ do |url|
+  @browser.get(URI.escape(url))
+end
+
+Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
+  expect{ @browser.get(URI.escape(url)) }.to_not raise_exception
+end
+
+Then /^the content type should be "([^\"]*)"$/ do |expected|
+  expect(@browser.last_response.content_type).to start_with(expected)
+end
+
+Then /^I should see "([^\"]*)"$/ do |expected|
+  expect(@browser.last_response.body).to include(expected)
+end
+
+Then /^I should see '([^\']*)'$/ do |expected|
+  expect(@browser.last_response.body).to include(expected)
+end
+
+Then /^I should see:$/ do |expected|
+  expect(@browser.last_response.body).to include(expected)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |expected|
+  expect(@browser.last_response.body).to_not include(expected)
+end
+
+Then /^I should not see:$/ do |expected|
+  expect(@browser.last_response.body).to_not include(expected.chomp)
+end
+
+Then /^the status code should be "([^\"]*)"$/ do |expected|
+  expect(@browser.last_response.status).to eq expected.to_i
+end
+
+Then /^I should see "([^\"]*)" lines$/ do |lines|
+  expect(@browser.last_response.body.chomp.split($/).length).to eq(lines.to_i)
+end

data/lib/middleman-core/templates.rb

@@ -0,0 +1,101 @@
+# Use thor for template generation
+require 'thor'
+require 'thor/group'
+
+# Templates namespace
+module Middleman::Templates
+  # Static methods
+  class << self
+    # Get list of registered templates and add new ones
+    #
+    #     Middleman::Templates.register(:ext_name, klass)
+    #
+    # @param [Symbol] name The name of the template
+    # @param [Class] klass The class to be executed for this template
+    # @return [Hash] List of registered templates
+    def register(name=nil, klass=nil)
+      @_template_mappings ||= {}
+      @_template_mappings[name] = klass if name && klass
+      @_template_mappings
+    end
+
+    # Middleman::Templates.register(name, klass)
+    alias_method :registered, :register
+  end
+
+  # Base Template class. Handles basic options and paths.
+  class Base < ::Thor::Group
+    include Thor::Actions
+
+    def initialize(names, options)
+      super
+      source_paths << File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    # The gemfile template to use. Individual templates can define this class
+    # method to override the template path.
+    def self.gemfile_template
+      'shared/Gemfile.tt'
+    end
+
+    # Required path for the new project to be generated
+    argument :location, type: :string
+
+    # Name of the template being used to generate the project.
+    class_option :template, default: 'default'
+
+    # Output a config.ru file for Rack if --rack is passed
+    class_option :rack, type: :boolean, default: false
+
+    # Write a Rack config.ru file for project
+    # @return [void]
+    def generate_rack!
+      return unless options[:rack]
+      template 'shared/config.ru', File.join(location, 'config.ru')
+    end
+
+    class_option :'skip-bundle', type: :boolean, default: false
+    class_option :'skip-gemfile', type: :boolean, default: false
+
+    # Write a Bundler Gemfile file for project
+    # @return [void]
+    def generate_bundler!
+      return if options[:'skip-gemfile']
+      template self.class.gemfile_template, File.join(location, 'Gemfile')
+
+      return if options[:'skip-bundle']
+      inside(location) do
+        ::Middleman::Cli::Bundle.new.invoke(:bundle)
+      end unless ENV['TEST']
+    end
+
+    # Output a .gitignore file
+    class_option :'skip-git', type: :boolean, default: false
+
+    # Write a .gitignore file for project
+    # @return [void]
+    def generate_gitignore!
+      return if options[:'skip-git']
+      copy_file 'shared/gitignore', File.join(location, '.gitignore')
+    end
+  end
+end
+
+# Default template
+require 'middleman-core/templates/default'
+
+# HTML5 template
+require 'middleman-core/templates/html5'
+
+# HTML5 Mobile template
+require 'middleman-core/templates/mobile'
+
+# SMACSS templates
+require 'middleman-more/templates/smacss'
+
+# Local templates
+# Sometimes HOME doesn't exist, in which case there's no point to local templates
+require 'middleman-core/templates/local' if ENV['HOME']
+
+# Barebones template
+require 'middleman-core/templates/empty'

data/lib/middleman-core/templates/default.rb

@@ -0,0 +1,37 @@
+# Default Middleman template
+class Middleman::Templates::Default < Middleman::Templates::Base
+  class_option 'css_dir',
+               default: 'stylesheets',
+               desc: 'The path to the css files'
+  class_option 'js_dir',
+               default: 'javascripts',
+               desc: 'The path to the javascript files'
+  class_option 'images_dir',
+               default: 'images',
+               desc: 'The path to the image files'
+
+  # Template files are relative to this file
+  # @return [String]
+  def self.source_root
+    File.dirname(__FILE__)
+  end
+
+  # Actually output the files
+  # @return [void]
+  def build_scaffold!
+    template 'shared/config.tt', File.join(location, 'config.rb')
+    copy_file 'default/source/index.html.erb', File.join(location, 'source/index.html.erb')
+    copy_file 'default/source/layouts/layout.erb', File.join(location, 'source/layouts/layout.erb')
+    empty_directory File.join(location, 'source', options[:css_dir])
+    copy_file 'default/source/stylesheets/all.css', File.join(location, 'source', options[:css_dir], 'all.css')
+    copy_file 'default/source/stylesheets/normalize.css', File.join(location, 'source', options[:css_dir], 'normalize.css')
+    empty_directory File.join(location, 'source', options[:js_dir])
+    copy_file 'default/source/javascripts/all.js', File.join(location, 'source', options[:js_dir], 'all.js')
+    empty_directory File.join(location, 'source', options[:images_dir])
+    copy_file 'default/source/images/background.png', File.join(location, 'source', options[:images_dir], 'background.png')
+    copy_file 'default/source/images/middleman.png', File.join(location, 'source', options[:images_dir], 'middleman.png')
+  end
+end
+
+# Register this template
+Middleman::Templates.register(:default, Middleman::Templates::Default)

data/lib/middleman-core/templates/default/source/index.html.erb

@@ -0,0 +1,10 @@
+---
+title: Welcome to Middleman
+---
+
+<div class="welcome">
+  <h1>Middleman is Watching</h1>
+  <p class="doc">
+    <%= link_to "Read Online Documentation", "http://middlemanapp.com/" %>
+  </p><!-- .doc -->
+</div><!-- .welcome -->

data/lib/middleman-core/templates/default/source/javascripts/all.js

@@ -0,0 +1 @@
+//= require_tree .

data/lib/middleman-core/templates/default/source/layouts/layout.erb

@@ -0,0 +1,19 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    
+    <!-- Always force latest IE rendering engine or request Chrome Frame -->
+    <meta content="IE=edge,chrome=1" http-equiv="X-UA-Compatible">
+    
+    <!-- Use title if it's in the page YAML frontmatter -->
+    <title><%= current_page.data.title || "The Middleman" %></title>
+    
+    <%= stylesheet_link_tag "normalize", "all" %>
+    <%= javascript_include_tag  "all" %>
+  </head>
+  
+  <body class="<%= page_classes %>">
+    <%= yield %>
+  </body>
+</html>

data/lib/middleman-core/templates/default/source/stylesheets/all.css

@@ -0,0 +1,55 @@
+@charset "utf-8";
+
+body {
+  background: #d4d4d4 url("../images/background.png");
+  text-align: center;
+  font-family: sans-serif; }
+
+h1 {
+  color: rgba(0, 0, 0, .3);
+  font-weight: bold;
+  font-size: 32px;
+  letter-spacing: -1px;
+  text-transform: uppercase;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, .5);
+  background: url("../images/middleman.png") no-repeat center 100px;
+  padding: 350px 0 10px;
+  margin: 0; }
+
+.doc {
+  font-size: 14px;
+  margin: 0; }
+  .doc:before,
+  .doc:after {
+    opacity: .2;
+    padding: 6px;
+    font-style: normal;
+    position: relative;
+    content: "•"; }
+  .doc a {
+    color: rgba(0, 0, 0, 0.3); }
+    .doc a:hover {
+      color: #666; }
+
+.welcome {
+  -webkit-animation-name: welcome;
+  -webkit-animation-duration: .9s; }
+
+@-webkit-keyframes welcome {
+  from {
+    -webkit-transform: scale(0);
+    opacity: 0;
+  }
+  50% {
+   -webkit-transform: scale(0);
+   opacity: 0;
+  }
+  82.5% {
+    -webkit-transform: scale(1.03);
+    -webkit-animation-timing-function: ease-out;
+    opacity: 1;
+  }
+  to {
+    -webkit-transform: scale(1);
+  }
+}