middleman-presentation-core 0.16.0.alpha

data/spec/slide_list_spec.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe SlideList do
+
+  context '#initialize' do
+    it 'requires a list of patterns' do
+      slide = double('Middleman::Presentation::NewSlide')
+      allow(slide).to receive(:name).and_return '01'
+
+      slide_builder = double('Middleman::Presentation::NewSlide')
+      allow(slide_builder).to receive(:new).and_return slide
+
+      expect do
+        SlideList.new('01', slide_builder: slide_builder)
+      end.not_to raise_error
+    end
+
+    it 'accepts a block' do
+      slide = double('Middleman::Presentation::NewSlide')
+      allow(slide).to receive(:name).and_return '01'
+
+      slide_builder = double('Middleman::Presentation::NewSlide')
+      allow(slide_builder).to receive(:new).and_return slide
+
+      expect do
+        SlideList.new('01', slide_builder: slide_builder) do |_l|
+        end
+      end.not_to raise_error
+    end
+  end
+
+  context '#all' do
+    it 'holds all slides: existing and not existing' do
+      touch_file '01'
+      touch_file '02'
+
+      slide_builder = double('Middleman::Presentation::NewSlide')
+
+      %w(01 02 03).each do |name|
+        expect(slide_builder).to receive(:new).with(name, {}).and_return(OpenStruct.new(name: name))
+      end
+
+      list = SlideList.new(%w(01 02 03), slide_builder: slide_builder)
+      expect(list.all.size).to eq 3
+    end
+  end
+
+  context '#transform_with' do
+    it 'takes a transformer to modify each entry' do
+      slide = double('Middleman::Presentation::NewSlide')
+      allow(slide).to receive(:name).and_return '01'
+
+      slide_builder = double('Middleman::Presentation::NewSlide')
+      allow(slide_builder).to receive(:new).and_return slide
+
+      transformer = double('Transformer')
+      expect(transformer).to receive(:transform)
+
+      SlideList.new(%w(01), slide_builder: slide_builder) do |l|
+        l.transform_with transformer
+      end
+    end
+  end
+
+  context '#each_new' do
+    it 'iterates over all non existing slides because they are assumed to be new' do
+      slide1 = double('Slide')
+      expect(slide1).to receive(:exist?).and_return false
+
+      slide2 = double('Slide')
+      expect(slide2).to receive(:exist?).and_return true
+
+      slide_builder = double('Middleman::Presentation::NewSlide')
+      allow(slide_builder).to receive(:new).and_return(slide1, slide2)
+
+      result = SlideList.new(%w(01 02), slide_builder: slide_builder).each_new
+      expect(result).to include slide1
+      expect(result).not_to include slide2
+    end
+  end
+
+  context '#each_existing' do
+    it 'iterates over all existing slides' do
+      slide1 = double('Slide')
+      expect(slide1).to receive(:exist?).and_return false
+
+      slide2 = double('Slide')
+      expect(slide2).to receive(:exist?).and_return true
+
+      slide_builder = double('Middleman::Presentation::NewSlide')
+      allow(slide_builder).to receive(:new).and_return(slide1, slide2)
+
+      result = SlideList.new(%w(01 02), slide_builder: slide_builder).each_existing
+      expect(result).not_to include slide1
+      expect(result).to include slide2
+    end
+  end
+
+  context '#existing_slides' do
+    it 'returns all existing slides' do
+      slide = double('Slide')
+      expect(slide).to receive(:exist?).and_return true
+
+      slide_builder = double('Middleman::Presentation::NewSlide')
+      allow(slide_builder).to receive(:new).and_return slide
+
+      existing_slides = SlideList.new(%w(01), slide_builder: slide_builder).existing_slides
+      expect(existing_slides).to include slide
+    end
+  end
+
+  context '#to_a' do
+    it 'converts list to array' do
+      slide1 = double('Slide')
+      slide2 = double('Slide')
+
+      slide_builder = double('Middleman::Presentation::NewSlide')
+      allow(slide_builder).to receive(:new).and_return(slide1, slide2)
+
+      result = SlideList.new(%w(01 02), slide_builder: slide_builder).to_a
+      expect(result).to eq [slide1, slide2]
+    end
+  end
+end

data/spec/slide_name_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe SlideName do
+  context '#to_s' do
+    let(:old_slide) { instance_double('Middleman::Presentation::ExistingSlide') }
+
+    it 'switches type from erb to md if no basename/type is given' do
+      expect(old_slide).to receive(:base_name).and_return('01')
+      expect(old_slide).to receive(:ext_name).and_return('.html.erb')
+
+      name = SlideName.new(old_slide, base_name: nil, type: nil)
+      expect(name.to_s).to eq '01.md'
+    end
+
+    it 'switches type from erb to md if no basename/type is given' do
+      expect(old_slide).to receive(:base_name).and_return('01')
+      expect(old_slide).to receive(:ext_name).and_return('.html.md')
+
+      name = SlideName.new(old_slide, base_name: nil, type: nil)
+      expect(name.to_s).to eq '01.erb'
+    end
+
+    it 'switches type from other types than erb/md to md only if no basename/type is given' do
+      expect(old_slide).to receive(:base_name).and_return('01')
+      expect(old_slide).to receive(:ext_name).and_return('.html.liquid')
+
+      name = SlideName.new(old_slide, base_name: nil, type: nil)
+      expect(name.to_s).to eq '01.md'
+    end
+
+    it 'switches to given type and uses base name from old slide' do
+      expect(old_slide).to receive(:base_name).and_return('01')
+
+      name = SlideName.new(old_slide, base_name: nil, type: 'erb')
+      expect(name.to_s).to eq '01.erb'
+    end
+
+    it 'switches to given type (with dot) and uses base name from old slide' do
+      expect(old_slide).to receive(:base_name).and_return('01')
+
+      name = SlideName.new(old_slide, base_name: nil, type: '.erb')
+      expect(name.to_s).to eq '01.erb'
+    end
+
+    it 'switches to given basename and uses type from old slide' do
+      expect(old_slide).to receive(:ext_name).and_return('.html.erb')
+
+      name = SlideName.new(old_slide, base_name: '02', type: nil)
+      expect(name.to_s).to eq '02.erb'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+SimpleCov.command_name 'rspec'
+SimpleCov.start
+
+# Pull in all of the gems including those in the `test` group
+require 'bundler'
+Bundler.require :default, :test, :development
+
+require 'middleman-presentation'
+
+# Loading support files
+Dir.glob(::File.expand_path('../support/*.rb', __FILE__)).each { |f| require_relative f }
+Dir.glob(::File.expand_path('../shared_examples/*.rb', __FILE__)).each { |f| require_relative f }
+
+# Avoid writing "describe MyModule::MyClass do [..]" but "describe MyClass do [..]"
+include Middleman::Presentation

data/spec/support/aruba.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+require 'aruba/api'
+require 'aruba/reporting'
+
+module Middleman
+  module Presentation
+    # Spec Helpers
+    module SpecHelper
+      # Helpers for aruba
+      module Aruba
+        include ::Aruba::Api
+
+        def dirs
+          @dirs ||= %w(tmp rspec)
+        end
+
+        def absolute_path(*args)
+          in_current_dir { File.expand_path File.join(*args) }
+        end
+
+        def _create_file(*args)
+          super
+
+          args.first
+        end
+
+        def create_dir(*args)
+          super
+
+          args.first
+        end
+
+        def touch_file(file_name)
+          in_current_dir do
+            file_name = File.expand_path(file_name)
+            _mkdir(File.dirname(file_name))
+            FileUtils.touch file_name
+          end
+
+          file_name
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include Middleman::Presentation::SpecHelper::Aruba
+  c.before :each do
+    clean_current_dir
+    restore_env
+  end
+end

data/spec/support/ci.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+# Test helpers
+require 'middleman-presentation-core/test_helpers'
+
+module Middleman
+  module Presentation
+    # Spec Helpers
+    module SpecHelper
+      # Helpers for ci
+      module Ci
+        include Middleman::Presentation::TestHelpers
+      end
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include Middleman::Presentation::SpecHelper::Ci
+end

data/spec/support/environment.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# require 'fedux_org_stdlib/environment'
+#
+# module Middleman
+#  module Presentation
+#    # Spec Helpers
+#    module SpecHelper
+#      # Helpers for environment
+#      module Environment
+#        include FeduxOrgStdlib::Environment
+#      end
+#    end
+#  end
+# end
+#
+# RSpec.configure do |c|
+#  c.include Middleman::Presentation::SpecHelper::Environment
+# end

data/spec/support/filesystem.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# require 'fedux_org_stdlib/filesystem'
+#
+# module Middleman
+#  module Presentation
+#    module SpecHelper
+#      # Helpers for filesystem
+#      module Filesystem
+#        include FeduxOrgStdlib::Filesystem
+#
+#        def root_directory
+#          ::File.expand_path('../../../', __FILE__)
+#        end
+#      end
+#    end
+#  end
+# end
+#
+# RSpec.configure do |c|
+#  c.include Middleman::Presentation::SpecHelper::Filesystem
+#  c.before(:each) { cleanup_working_directory }
+# end

data/spec/support/locale.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+Middleman::Presentation.locale_configurator.use_locale :en

data/spec/support/reporting.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'active_support/core_ext/kernel/reporting'

data/spec/support/rspec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+RSpec.configure do |config|
+  config.filter_run_including focus: true
+  config.run_all_when_everything_filtered = true
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+  end
+end

data/spec/support/string.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'active_support/core_ext/string/strip'

data/spec/transformers/file_keeper_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe Transformers::FileKeeper do
+  context '#transform' do
+    it 'removes directories from array and keep files' do
+      slide1 = instance_double('Middleman::Presentation::NewSlide')
+      file = touch_file('01.html.erb')
+      allow(slide1).to receive(:path).and_return absolute_path(file)
+
+      slide2 = instance_double('Middleman::Presentation::NewSlide')
+      directory = create_dir('01_dir')
+      allow(slide2).to receive(:path).and_return absolute_path(directory)
+
+      slides = []
+      slides << slide2
+      slides << slide1
+
+      slides = Transformers::FileKeeper.new.transform(slides)
+      expect(slides).to include slide1
+      expect(slides).not_to include slide2
+    end
+  end
+end

data/spec/transformers/group_slides_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe Transformers::GroupSlides do
+  context '#initialize' do
+    it 'requires a base directory' do
+      template = double('Template')
+      allow(template).to receive(:result)
+
+      expect do
+        Transformers::GroupSlides.new(template: template)
+      end.not_to raise_error
+    end
+  end
+
+  context '#transforms' do
+    it 'groups slides with same group' do
+      slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+      allow(slide1).to receive(:group).and_return 'group'
+      allow(slide1).to receive(:group?).and_return true
+      allow(slide1).to receive(:render).and_return '01'
+
+      slide2 = instance_double('Middleman::Presentation::ExistingSlide')
+      allow(slide2).to receive(:group).and_return 'group'
+      allow(slide2).to receive(:group?).and_return true
+      allow(slide2).to receive(:render).and_return '02'
+
+      slide3 = instance_double('Middleman::Presentation::ExistingSlide')
+      allow(slide3).to receive(:group).and_return nil
+      allow(slide3).to receive(:group?).and_return false
+      allow(slide3).to receive(:render).and_return '03'
+
+      transformer = Transformers::GroupSlides.new(template: Erubis::Eruby.new('<%= slides %>'))
+      result = transformer.transform [slide1, slide2, slide3]
+
+      expect(result).not_to include slide1
+      expect(result).not_to include slide2
+      expect(result).to include slide3
+
+      group = result.first
+      expect(group.render { |s| s }).to include "01\n02"
+    end
+  end
+end

data/spec/transformers/ignore_slides_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe Transformers::IgnoreSlides do
+  context '#transform' do
+    it 'ignores slides based on file name' do
+      ignore_file = write_file '.slidesignore', <<-EOS.strip_heredoc
+      02.html.md
+      EOS
+
+      slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+      allow(slide1).to receive(:match?).and_return(false)
+
+      slide2 = instance_double('Middleman::Presentation::ExistingSlide')
+      allow(slide2).to receive(:match?).and_return(false)
+      allow(slide2).to receive(:match?).with(/(?-mix:^!$)|(?-mix:02.html.md)/).and_return(true)
+
+      transformer = Transformers::IgnoreSlides.new ignore_file: absolute_path(ignore_file)
+      result = transformer.transform([slide1, slide2])
+
+      expect(result).to include slide1
+      expect(result).not_to include slide2
+    end
+
+    it 'unignores slides based on file name' do
+      ignore_file = write_file '.slidesignore', <<-EOS.strip_heredoc
+      .md$
+      !02.html.md
+      EOS
+
+      slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+      allow(slide1).to receive(:match?).with(/(?-mix:^!$)|(?-mix:.md$)/).and_return(false)
+      allow(slide1).to receive(:match?).with(/(?-mix:^!$)|(?-mix:02.html.md)/).and_return(true)
+
+      slide2 = instance_double('Middleman::Presentation::ExistingSlide')
+      allow(slide2).to receive(:match?).with(/(?-mix:^!$)|(?-mix:.md$)/).and_return(true)
+      allow(slide2).to receive(:match?).with(/(?-mix:^!$)|(?-mix:02.html.md)/).and_return(true)
+
+      slide3 = instance_double('Middleman::Presentation::ExistingSlide')
+      allow(slide3).to receive(:match?).with(/(?-mix:^!$)|(?-mix:.md$)/).and_return(true)
+      allow(slide3).to receive(:match?).with(/(?-mix:^!$)|(?-mix:02.html.md)/).and_return(false)
+
+      transformer = Transformers::IgnoreSlides.new ignore_file: absolute_path(ignore_file)
+      result = transformer.transform([slide1, slide2, slide3])
+
+      expect(result).to include slide1
+      expect(result).to include slide2
+      expect(result).not_to include slide3
+    end
+
+    it 'handles non existing ignore file' do
+      slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+      slide2 = instance_double('Middleman::Presentation::ExistingSlide')
+      slide3 = instance_double('Middleman::Presentation::ExistingSlide')
+
+      transformer = Transformers::IgnoreSlides.new ignore_file: SecureRandom.hex
+      result = transformer.transform([slide1, slide2, slide3])
+
+      expect(result).to include slide1
+      expect(result).to include slide2
+      expect(result).to include slide3
+    end
+  end
+end

data/spec/transformers/remove_duplicate_slides_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe Transformers::RemoveDuplicateSlides do
+  context '#transform' do
+    it 'removes similar slides: same basename but different file name' do
+      slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+      slide2 = instance_double('Middleman::Presentation::ExistingSlide')
+      slide3 = instance_double('Middleman::Presentation::ExistingSlide')
+
+      allow(slide1).to receive(:eql?).with(slide1).and_return(true)
+      allow(slide1).to receive(:eql?).with(slide2).and_return(false)
+      allow(slide1).to receive(:eql?).with(slide3).and_return(false)
+      allow(slide1).to receive(:similar?).with(slide1).and_return(false)
+      allow(slide1).to receive(:similar?).with(slide2).and_return(true)
+      allow(slide1).to receive(:similar?).with(slide3).and_return(false)
+
+      allow(slide2).to receive(:eql?).with(slide1).and_return(false)
+      allow(slide2).to receive(:eql?).with(slide2).and_return(true)
+      allow(slide2).to receive(:eql?).with(slide3).and_return(false)
+      allow(slide2).to receive(:similar?).with(slide1).and_return(true)
+      allow(slide2).to receive(:similar?).with(slide2).and_return(false)
+      allow(slide2).to receive(:similar?).with(slide3).and_return(false)
+
+      allow(slide3).to receive(:eql?).with(slide1).and_return(false)
+      allow(slide3).to receive(:eql?).with(slide2).and_return(false)
+      allow(slide3).to receive(:eql?).with(slide3).and_return(true)
+      allow(slide3).to receive(:similar?).with(slide1).and_return(false)
+      allow(slide3).to receive(:similar?).with(slide2).and_return(false)
+      allow(slide3).to receive(:similar?).with(slide3).and_return(false)
+
+      transformer = Transformers::RemoveDuplicateSlides.new
+      result      = transformer.transform([slide1, slide2, slide3])
+
+      expect(result).not_to include slide1
+      expect(result).not_to include slide2
+      expect(result).to include slide3
+    end
+
+    it 'raises an error on similar slides' do
+      slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+      slide2 = instance_double('Middleman::Presentation::ExistingSlide')
+
+      allow(slide1).to receive(:eql?).with(slide1).and_return(false)
+      allow(slide1).to receive(:eql?).with(slide2).and_return(false)
+      allow(slide1).to receive(:file_name).and_return('01.html.erb')
+      allow(slide1).to receive(:similar?).with(slide1).and_return(true)
+      allow(slide1).to receive(:similar?).with(slide2).and_return(true)
+
+      allow(slide2).to receive(:eql?).with(slide1).and_return(false)
+      allow(slide2).to receive(:eql?).with(slide2).and_return(false)
+      allow(slide2).to receive(:file_name).and_return('01.html.md')
+      allow(slide2).to receive(:similar?).with(slide1).and_return(true)
+      allow(slide2).to receive(:similar?).with(slide2).and_return(true)
+
+      transformer = Transformers::RemoveDuplicateSlides.new raise_error: true
+
+      expect do
+        transformer.transform([slide1, slide2])
+      end.to raise_error ArgumentError
+    end
+
+    it 'considers additional slides which will be not part of the output' do
+      slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+      slide2 = instance_double('Middleman::Presentation::ExistingSlide')
+      slide3 = instance_double('Middleman::Presentation::ExistingSlide')
+      slide4 = instance_double('Middleman::Presentation::ExistingSlide')
+
+      allow(slide1).to receive(:file_name).and_return '01.html.erb'
+      allow(slide1).to receive(:eql?).with(slide1).and_return(true)
+      allow(slide1).to receive(:eql?).with(slide2).and_return(true)
+      allow(slide1).to receive(:eql?).with(slide3).and_return(false)
+      allow(slide1).to receive(:eql?).with(slide4).and_return(false)
+      allow(slide1).to receive(:similar?).with(slide1).and_return(false)
+      allow(slide1).to receive(:similar?).with(slide2).and_return(true)
+      allow(slide1).to receive(:similar?).with(slide3).and_return(false)
+      allow(slide1).to receive(:similar?).with(slide4).and_return(false)
+
+      allow(slide2).to receive(:file_name).and_return '01.html.md'
+      allow(slide2).to receive(:eql?).with(slide1).and_return(false)
+      allow(slide2).to receive(:eql?).with(slide2).and_return(true)
+      allow(slide2).to receive(:eql?).with(slide3).and_return(false)
+      allow(slide2).to receive(:eql?).with(slide4).and_return(false)
+      allow(slide2).to receive(:similar?).with(slide1).and_return(true)
+      allow(slide2).to receive(:similar?).with(slide2).and_return(false)
+      allow(slide2).to receive(:similar?).with(slide3).and_return(false)
+      allow(slide2).to receive(:similar?).with(slide4).and_return(false)
+
+      allow(slide2).to receive(:file_name).and_return '02.html.md'
+      allow(slide3).to receive(:eql?).with(slide1).and_return(false)
+      allow(slide3).to receive(:eql?).with(slide2).and_return(false)
+      allow(slide3).to receive(:eql?).with(slide3).and_return(true)
+      allow(slide3).to receive(:eql?).with(slide4).and_return(false)
+      allow(slide3).to receive(:similar?).with(slide1).and_return(false)
+      allow(slide3).to receive(:similar?).with(slide2).and_return(false)
+      allow(slide3).to receive(:similar?).with(slide3).and_return(false)
+      allow(slide3).to receive(:similar?).with(slide4).and_return(false)
+
+      allow(slide2).to receive(:file_name).and_return '03.html.md'
+      allow(slide4).to receive(:eql?).with(slide1).and_return(false)
+      allow(slide4).to receive(:eql?).with(slide2).and_return(false)
+      allow(slide4).to receive(:eql?).with(slide3).and_return(false)
+      allow(slide4).to receive(:eql?).with(slide4).and_return(true)
+      allow(slide4).to receive(:similar?).with(slide1).and_return(false)
+      allow(slide4).to receive(:similar?).with(slide2).and_return(false)
+      allow(slide4).to receive(:similar?).with(slide3).and_return(false)
+      allow(slide4).to receive(:similar?).with(slide4).and_return(false)
+
+      transformer = Transformers::RemoveDuplicateSlides.new additional_slides: [slide2, slide4]
+      result = transformer.transform([slide1, slide3])
+
+      # slide1 cannot be part of output
+      # because a similar slide already exists
+      expect(result).not_to include slide1
+      expect(result).not_to include slide2
+      expect(result).not_to include slide4
+      expect(result).to include slide3
+    end
+  end
+end

data/spec/transformers/sort_slides_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe Transformers::SortSlides do
+  context '#transform' do
+    it 'sorts slides' do
+      slides = []
+      slides << 1
+      slides << 3
+      slides << 2
+
+      slides = Transformers::SortSlides.new.transform(slides)
+      expect(slides.first).to eq 1
+      expect(slides.last).to eq 3
+    end
+  end
+end

data/spec/utils_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe Utils do
+  context '#zip' do
+    it 'creates a zip archive from directory' do
+      touch_file 'test.txt'
+
+      Middleman::Presentation::Utils.zip absolute_path('.'), absolute_path('test.zip')
+
+      check_file_presence(['test.zip'], true)
+    end
+  end
+end

data/templates/.bowerrc.tt

@@ -0,0 +1,4 @@
+{
+  "directory": "<%= @bower_directory %>",
+    "json": "bower.json"
+}

data/templates/.gitignore

@@ -0,0 +1,5 @@
+/.bundle
+/build
+/.sass-cache
+/.cache
+.DS_Store

data/templates/Gemfile.tt

@@ -0,0 +1,32 @@
+source 'https://rubygems.org'
+
+gem 'middleman'
+
+# For faster file watcher updates on Windows:
+# gem 'wdm', :platforms => [:mswin, :mingw]
+
+<% if Middleman::Presentation.config.runtime_environment == :test -%>
+# Make sure the paths are correct, otherwise you get
+# Bundler-errors a la `Path does not exist`
+gem 'middleman-presentation', path: '<%= File.join(@rubygem_path, 'middleman-presentation') %>'
+gem 'middleman-presentation-core', path: '<%= File.join(@rubygem_path, 'middleman-presentation-core') %>'
+gem 'middleman-presentation-helpers', path: '<%= File.join(@rubygem_path, 'middleman-presentation-helpers') %>'
+gem 'middleman-presentation-simple_plugin', path: '<%= File.join(@rubygem_path, 'middleman-presentation-core/fixtures/middleman-presentation-simple_plugin') %>'
+<% else -%>
+gem 'middleman-presentation'
+<% end -%>
+
+# Choose one to make `execjs` happy
+# gem 'therubyracer'
+# gem 'therubyrhino'
+
+gem 'kramdown'
+gem 'github-markup'
+gem 'liquid'
+gem 'rake'
+
+group :debug do
+  gem 'pry'
+  gem 'byebug'
+  gem 'pry-byebug'
+end

data/templates/LICENSE.presentation

@@ -0,0 +1 @@
+This is a stub. Please place the license or a link to the license for your presentation here.