playgroundbook 0.4.0 → 0.5.0

data/spec/fixtures/wrapper/source/swift_at_artsy_1.md

@@ -1,183 +0,0 @@
-(Note: a screen recording of a presentation of this material is [available on YouTube](https://github.com/artsy/Swift-at-Artsy/tree/master/Beginners/Lesson%20One).)
-
-Hey! So we're going to be looking at Swift from the perspective of learning programming. This means you get to ask awkward questions and I struggle to verbalise concepts that are the programming equivalent of muscle memory. It'll be fun!
-
-To start off we need to get to a point where we can write any code. We're going to assume that you already have a copy of Xcode 7 installed. With that, let's get started!
-
-Open Xcode and you'll get this Welcome dialogue. 
-
-![Xcode Welcome Screen](img/welcome.png)
-
-We'll be using _playgrounds_ to learn Swift. Click "Get started with a playground", give it a name, and make sure the platform is set to **OS X**. 
-
-![Creating a new playground](img/newplayground.png)
-
-Awesome. Xcode will create an open the playground for you. It'll look something like this. 
-
-![Empty Playground](img/emptyplayground.png)
-
-The large pane on the left is where we're going to write code. On the right is where the results of our code are displayed. You can see that there's already one line of code written for us, `var str = "Hello, playground"`, and the results pane says `"Hello, playground"`. Neat. 
-
-
-Normally for things I work with, the code we are writing gets transformed from something we, as humans, kind-of understand to something a machine understands via a compiler. Let's stick with the idea that it's basically a translator from human to machine. Normally its a big upfront conversion, for example Eigen can take 5 minutes to compile. 
-
-We're going to use Playgrounds, which is more like a back and forth conversation with the compiler, so it's much faster to write code and test things out. These are called REPLs.
-
-What this means is whatever you type will be run by Xcode and the results will be shown on the right. When Xcode is compiling code (whenever you change text), the top bar of the window will change to say "Running" and will show a little spinner. 
-
-Let's start by saying what _isn't_ code. You see the the first line, how it is greyed out? Well that's a comment. Comments are annotations in the code that are not ran by the compiler. We'll be using comments occasionally to skip bits of code, or to remind us what something is.
-
-OK let's write some code, let's try typing some things. 
-
-```swift
-1 + 2
-
-1 / 2
-1.0 / 2.0
-
-"Hello, Artsy"
-```
-
-You can see the results in the results pane:
-
-![Results](img/results.png)
-
-In programming, we want to work with abstractions. So let's make our first variable. A variable holds a value that you can refer to later, you can name them (almost) whatever you want. 
-
-Variables are themselves an abstract concept, and it's normal for beginners to take time getting comfortable with them. In essence, a variable is a way to store something in a place that you can refer to later. There are a few good reasons to do this, but the most common one is that we need to refer to the same value more than once. 
-
-On an artist's Artsy page, we show their name more than once. It's useful to be able to store the artists name in a variable _once_ and then refer to that variable multiple times to show the user an artist's page.
-
-We're going to make a simple calculator with 3  variables. What I'd like to do is define a variable called `a` and `b` then add them together to make `c`. This is a simple example, but it's about foundations.
-
-```swift
-var a = 2
-var b = 3
-
-var c = a + b
-```
-
-In this case, you can see that we're referring back to `a` and `b` as variables, instead of the numbers `2` and `3`. This is a simple example, and with more experience, you'll get more comfortable. 
-
-Variables all have a _type_. Some variables are numbers, and some are strings, and some are other things, too! Numbers are often `Int`, or an integer (basically a round number: 1, 2, 3, -500, 401). Swift is a **strongly-typed language**, which means that types matter a lot. Swift won't let you confuse one type for another. Even though we haven't _told_ Swift what the type of our variables are, the compiler figures it out automatically. 
-
-In Swift, `:` specifies a type. So the following two lines are equivalent.
-
-```swift
-var myString = "Hello, Artsy"
-var myString: String = "Hello, Artsy"
-```
-
-In this case we're dealing with a collection of letters, that combined, we call a string. This is common terminology in most programming languages, think of it as a string of letters.
-
-```swift
-var myString: String = 1
-```
-
-Swift will complain and say that `'Int' is not convertible to 'String'`. This is Swift's compile-time type checking. It prevents bugs from happening in apps at runtime by giving you errors before-hand. Swift's primary goal is safety against crashes in apps. 
-
-When we're writing code, very often we want to print out some useful information for someone to read. We're going to use this to show that some of our code is running. So lets add a print statement saying what the value of `c` is:
-
-```swift
-print(c)
-``` 
-
-With `print` working, we can start doing some logic. We want to start checking how big our `c` is, and just like in English, we'll use an `if` statement:
-
-```swift
-if c > 6 {
-    print("Pretty big c you got there.")
-}
-```
-
-Let's unpack what we're seeing here. `if [something]` - what's happening here is that the bit after the `if` is checking to see if `c` is greater than the number (`Int`) `6`. If it is, then it will run the code inside the braces. 
-
-`if` statements are fundamentally about doing some code only under certain circumstances. For example, Artsy only shows the "Inquire on Artwork" button **if** that artwork can be inquired upon. There are lots of different places in our code where it's useful to do something only if a condition is met.
-
-It is common to use a left margin / indentation to indicate that something is inside a braced section. It's not enforced though.
-
-```swift
-if c > 6 {
-            print("Pretty big c you got there.")
-}
-```
-
-```swift
-if c > 6 { 
-print("Pretty big c you got there.") 
-}
-```
-
-```swift
-if c > 6 { print("Pretty big c you got there.") }
-```
-
-We've got one more thing to go over, and that is loops. Loops repeat a section of code. Computers are really good at doing the same thing over and over, and loops are how programmers tell computers to do that. Repeating code is really useful in the Artsy's artwork pages, specifically in the related artworks section. As programmers, we tell the computer how to add _one_ artwork to the page, and then tell the computer to do that over and over for all the related artworks.
-
-Let's make a nice simple loop, one that reads like English. For _a_ number in _zero to c_. 
-
-```swift
-for number in 0...c {
-    print("hi")
-}
-```
-
-It has the same behavior that we saw in the `if` example. It will run the thing inside the braces as many times as the value of `c`. Each time it will print out `"hi"`. I think we can expand on this one little bit. The word `number` here is actually a variable, let's make it sound all mathematical and call it `x` instead.
-
-```swift
-for x in 0...c {
-    print("hi")
-}
-```
-
-Now we know it's a variable, lets print it!
-
-```swift
-for x in 0...c {
-    print(x)
-}
-```
-
-For loops, often just called "loops", are foundational to programming. In this example above, we've looped over all the numbers from `0` to `c`, but you can loop over other things, too. Say we're making an app at Artsy that shows a bunch of artworks – we might loop over all the artworks to show them on the screen. 
-
-If you hit the little triangle in the bottom left you can see the printed output!
-
-----------------
-
-So let's recap.
-
-* We've learned a little bit about variables, they are named values that make it easier for us to think about what something represents vs what it is.
-
-* Then we looked at some `String`s, and showed that you can't change something from a string to a number once you've start using it as a `String`,
-
-* We then printed some information.
-
-* After that we looked at adding an `if` statement to add some logic to our code.
-
-* Finally we wrapped up with a `for in` loop.
-
-If you're keen, feel free to keep playing in the playground. Try changing things in the loops to see what happens. Is it what you expected to happen? Why or why not?
-
-What do you think this code would do?
-
-```swift
-for number in 0...15 {
-	if number > 5 {
-		print("This is greater than five")
-	}
-}
-```
-
-What about this?
-
-```swift
-for number in 0...15 {
-	if number > 5 {
-		print("This is greater than five")
-	} else {
-		print("This is less than five")
-	}
-}
-```
-
-You can also look at the free Stanford Swift Course: https://www.youtube.com/playlist?list=PLxwBNxx9j4PW4sY-wwBwQos3G6Kn3x6xP

data/spec/linter/chapter_linter_spec.rb

@@ -1,30 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe RootManifestLinter do
-    include FakeFS::SpecHelpers
-    let(:chapter_linter) { ChapterLinter.new(chapter_manifest_linter) }
-    let(:chapter_manifest_linter) { double(ChapterManifestLinter) }
-    let(:chapter_directory_name) { "test_chapter" }
-
-    it "fails when chapter directory does not exist" do
-      expect { chapter_linter.lint(chapter_directory_name) }.to raise_error(SystemExit)
-    end
-
-    it "fails when Pages subdirectory of chapter dir does not exist" do
-      FakeFS do
-        Dir.mkdir(chapter_directory_name)
-        expect { chapter_linter.lint(chapter_directory_name) }.to raise_error(SystemExit)
-      end
-    end
-
-    it "calls through to chapter manifest linter" do
-      FakeFS do
-        expect(chapter_manifest_linter).to receive(:lint)
-        FileUtils.mkdir_p("#{chapter_directory_name}/Pages")
-
-        expect { chapter_linter.lint(chapter_directory_name) }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/linter/chapter_manifest_linter_spec.rb

@@ -1,40 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe ChapterManifestLinter do
-    include FakeFS::SpecHelpers
-    let(:chapter_manifest_linter) { ChapterManifestLinter.new(page_linter) }
-    let(:page_linter) { double(PageLinter) }
-    let(:page_directory_name) { "test.playgroundpage" }
-
-    it "fails if no Pages defined in Manifest" do
-      FakeFS do
-        plist = { "Name" => "Test" }.to_plist
-        File.open("Manifest.plist", "w") { |f| f.write(plist) }
-
-        expect { chapter_manifest_linter.lint }.to raise_error(SystemExit)
-      end
-    end
-
-    it "fails if Pages dir specified in Manifest does not exist" do
-      FakeFS do
-        plist = { "Name" => "Test", "Pages" => [page_directory_name] }.to_plist
-        File.open("Manifest.plist", "w") { |f| f.write(plist) }
-        Dir.mkdir("Pages")
-
-        expect { chapter_manifest_linter.lint }.to raise_error(SystemExit)
-      end
-    end
-
-    it "calls through to page linter" do
-      FakeFS do
-        expect(page_linter).to receive(:lint)
-        plist = { "Name" => "Test", "Pages" => [page_directory_name] }.to_plist
-        File.open("Manifest.plist", "w") { |f| f.write(plist) }
-        FileUtils.mkdir_p("Pages/#{page_directory_name}")
-
-        expect { chapter_manifest_linter.lint }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/linter/contents_linter_spec.rb

@@ -1,18 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe ContentsLinter do
-    include FakeFS::SpecHelpers
-    let(:contents_linter) { ContentsLinter.new(root_manifest_linter) }
-    let(:root_manifest_linter) { double(RootManifestLinter) }
-
-    it "calls through to root manifest linter" do
-      expect(root_manifest_linter).to receive(:lint)
-
-      FakeFS do
-        Dir.mkdir "Contents"
-        contents_linter.lint
-      end
-    end
-  end
-end

data/spec/linter/cutscene_page_linter_spec.rb

@@ -1,14 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe CutscenePageLinter do
-    include FakeFS::SpecHelpers
-    let(:cutscene_page_linter) { CutscenePageLinter.new(cutscene_page_manifest_linter) }
-    let(:cutscene_page_manifest_linter) { double(CutscenePageManifestLinter) }
-
-    it "passes through to cutscene_page_manifest_linter" do
-      expect(cutscene_page_manifest_linter).to receive(:lint)
-      expect { cutscene_page_linter.lint }.to_not raise_error
-    end
-  end
-end

data/spec/linter/cutscene_page_manifest_linter_spec.rb

@@ -1,63 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe CutscenePageManifestLinter do
-    include FakeFS::SpecHelpers
-    let(:cutscene_page_manifest_linter) { CutscenePageManifestLinter.new }
-
-    it "given a valid manifest does not fail" do
-      FakeFS do
-        cutscene_reference = "RealFile.html"
-        plist = {
-          "Name" => "Test Page",
-          "CutsceneReference" => cutscene_reference
-        }.to_plist
-        File.open("Manifest.plist", "w") { |f| f.write(plist) }
-        File.open(cutscene_reference, "w")
-
-        expect { cutscene_page_manifest_linter.lint }.not_to raise_error
-      end
-    end
-
-    context "given a cutscene path" do
-      it "fails if the key doesn't exist" do
-        FakeFS do
-          cutscene_reference = "FakeFile.html"
-          plist = {
-            "Name" => "Test Page"
-          }.to_plist
-          File.open("Manifest.plist", "w") { |f| f.write(plist) }
-
-          expect { cutscene_page_manifest_linter.lint }.to raise_error(SystemExit)
-        end
-      end
-
-      it "fails if that file doesn't exist" do
-        FakeFS do
-          cutscene_reference = "FakeFile.html"
-          plist = {
-            "Name" => "Test Page",
-            "CutsceneReference" => cutscene_reference
-          }.to_plist
-          File.open("Manifest.plist", "w") { |f| f.write(plist) }
-
-          expect { cutscene_page_manifest_linter.lint }.to raise_error(SystemExit)
-        end
-      end
-
-      it "fails with a non-HTML file" do
-        FakeFS do
-          cutscene_reference = "RealFile.xml"
-          plist = {
-            "Name" => "Test Page",
-            "CutsceneReference" => cutscene_reference
-          }.to_plist
-          File.open("Manifest.plist", "w") { |f| f.write(plist) }
-          File.open(cutscene_reference, "w")
-
-          expect { cutscene_page_manifest_linter.lint }.to raise_error(SystemExit)
-        end
-      end
-    end
-  end
-end

data/spec/linter/manfiest_linter_spec.rb

@@ -1,71 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe RootManifestLinter do
-    include FakeFS::SpecHelpers
-    let(:manifest_linter) { ManifestLinter.new }
-
-    it "fails if a Manifest.plist file does not exist" do
-      expect { manifest_linter.lint }.to raise_error(SystemExit)
-    end
-
-    it "fails if the Manifest.plist file does not contain a Name value" do
-      FakeFS do
-        plist = {}.to_plist
-        File.open("Manifest.plist", "w") { |f| f.write(plist) }
-
-        expect { manifest_linter.lint }.to raise_error(SystemExit)
-      end
-    end
-
-    it "succeeds if the Manifest.plist file is well-formed" do
-      FakeFS do
-        plist = { "Name" => "My Test Name" }.to_plist
-        File.open("Manifest.plist", "w") { |f| f.write(plist) }
-
-        expect { manifest_linter.lint }.to_not raise_error
-      end
-    end
-
-    it "extracts Manfiest.plist contents from pwd" do
-      FakeFS do
-        contents = { "key" => "value" }
-        File.open("Manifest.plist", "w") { |f| f.write(contents.to_plist) }
-
-        expect(manifest_linter.manifest_plist_contents).to eq(contents)
-      end
-    end
-
-    describe "key-value checking" do
-      before do
-      end
-
-      it "checks for non-defined keys in manifest" do
-        FakeFS do
-          plist = {}.to_plist
-          File.open("Manifest.plist", "w") { |f| f.write(plist) }
-
-          expect(manifest_linter.value_defined_in_manifest?("key")).to be_falsy
-        end
-      end
-
-      it "checks for nil keys in manifest" do
-        FakeFS do
-          plist = { "key" => nil }.to_plist
-          File.open("Manifest.plist", "w") { |f| f.write(plist) }
-
-          expect(manifest_linter.value_defined_in_manifest?("key")).to be_falsy
-        end
-      end
-
-      it "checks for empty keys in manifest" do
-        FakeFS do
-          plist = { "key" => "value" }.to_plist
-          File.open("Manifest.plist", "w") { |f| f.write(plist) }
-
-          expect(manifest_linter.value_defined_in_manifest?("key")).to be_truthy
-        end
-      end
-    end
-  end
-end

data/spec/linter/page_linter_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe PageLinter do
-    include FakeFS::SpecHelpers
-    let(:page_linter) { PageLinter.new(page_manifest_linter) }
-    let(:page_manifest_linter) { double(PageManifestLinter) }
-
-    it "fails if Contents.swift does not exist" do
-      expect { page_linter.lint }.to raise_error(SystemExit)
-    end
-
-    it "passes through to page_manifest_linter" do
-      File.open(ContentsSwiftFileName, "w") { |f| f.write("") }
-      expect(page_manifest_linter).to receive(:lint)
-      expect { page_linter.lint }.to_not raise_error
-    end
-  end
-end

data/spec/linter/page_manifest_linter_spec.rb

@@ -1,43 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe PageManifestLinter do
-    include FakeFS::SpecHelpers
-    let(:page_manifest_linter) { PageManifestLinter.new }
-
-    it "given a valid manifest does not fail" do
-      # TODO: We're not checking optional values yet, more tests to come.
-      # See page_manifest_linter.rb and https://github.com/ashfurrow/playground-book-lint/issues/3 for details.
-
-      FakeFS do
-        plist = { "Name" => "Test Page" }.to_plist
-        File.open("Manifest.plist", "w") { |f| f.write(plist) }
-        expect { page_manifest_linter.lint }.to_not raise_error
-      end
-    end
-
-    describe "context given a live view mode" do
-      it "succeeds with valid values" do
-        FakeFS do
-          plist = {
-            "Name" => "Test Page",
-            "LiveViewMode" => "HiddenByDefault"
-          }.to_plist
-          File.open("Manifest.plist", "w") { |f| f.write(plist) }
-          expect { page_manifest_linter.lint }.to_not raise_error
-        end
-      end
-
-      it "fails with invalid values" do
-        FakeFS do
-          plist = {
-            "Name" => "Test Page",
-            "LiveViewMode" => "UnsupportedViewMode"
-          }.to_plist
-          File.open("Manifest.plist", "w") { |f| f.write(plist) }
-          expect { page_manifest_linter.lint }.to raise_error(SystemExit)
-        end
-      end
-    end
-  end
-end

data/spec/linter/playgroundbook_lint_spec.rb

@@ -1,38 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe Linter do
-    let(:linter) { Linter.new(test_playground_book, contents_linter) }
-    let(:contents_linter) { double(ContentsLinter) }
-
-    it "initializes correctly" do
-      expect(linter.playground_file_name) == test_playground_book
-    end
-
-    it "exits on lint failure" do
-      allow(linter).to receive(:contents_dir_exists?)
-        .and_return(false)
-
-      expect { linter.lint }.to raise_error(SystemExit)
-    end
-
-    it "fails when file does not exist" do
-      allow(linter).to receive(:contents_dir_exists?)
-        .and_return(false)
-      allow(linter).to receive(:fail_lint)
-        .with("No Contents directory")
-        .and_raise(SystemExit)
-
-      expect { linter.lint }.to raise_error(SystemExit)
-    end
-
-    it "lints" do
-      allow(linter).to receive(:contents_dir_exists?)
-        .and_return(true)
-      allow(contents_linter).to receive(:lint)
-      expect(Dir).to receive(:chdir).with(test_playground_book)
-
-      linter.lint
-    end
-  end
-end

data/spec/linter/root_manifest_linter_spec.rb

@@ -1,35 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe RootManifestLinter do
-    include FakeFS::SpecHelpers
-    let(:root_manifest_linter) { RootManifestLinter.new(chapter_linter) }
-    let(:chapter_linter) { double(ChapterLinter) }
-
-    it "fails if Chapters directory does not exist" do
-      expect { root_manifest_linter.lint }.to raise_error(SystemExit)
-    end
-
-    it "fails if manfiest does not include Chapters" do
-      FakeFS do
-        Dir.mkdir("Chapters")
-        plist = { "Name" => "Test" }.to_plist
-        File.open("Manifest.plist", "w") { |f| f.write(plist) }
-
-        expect { root_manifest_linter.lint }.to raise_error(SystemExit)
-      end
-    end
-
-    it "calls through to lint each chapter" do
-      FakeFS do
-        plist = { "Chapters" => ["test_chapter_name"], "Name" => "Test" }.to_plist
-        File.open("Manifest.plist", "w") { |f| f.write(plist) }
-        Dir.mkdir("Chapters")
-
-        expect(chapter_linter).to receive(:lint).with("test_chapter_name")
-
-        expect { root_manifest_linter.lint }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/renderer/chapter_collator_spec.rb

@@ -1,70 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe ChapterCollator do
-    include FakeFS::SpecHelpers
-    let(:collator) { ChapterCollator.new(page_writer, test_ui) }
-    let(:page_writer) { double(PageWriter) }
-    let(:test_ui) { Cork::Board.new(silent: true) }
-    let(:parsed_chapter) { PageParser.new.parse_chapter_pages(test_chapter_contents) }
-    let(:chapter_name) { "test_chapter" }
-
-    before do
-      allow(page_writer).to receive(:write_page)
-    end
-
-    it "creates a chapter manifest" do
-      collator.collate(chapter_name, parsed_chapter, [])
-
-      expect(File.exist?("#{chapter_name}.playgroundchapter/#{ManifestFileName}")).to be_truthy
-    end
-
-    context "the chapter manifest" do
-      before do
-        collator.collate(chapter_name, parsed_chapter, ["UIKit"])
-      end
-
-      it "has the correct name" do
-        expect(get_manifest("#{chapter_name}.playgroundchapter/#{ManifestFileName}")["Name"]).to eq(chapter_name)
-      end
-
-      it "has the correct pages" do
-        expect(get_manifest("#{chapter_name}.playgroundchapter/#{ManifestFileName}")["Pages"]).to eq([
-                                                                                                       "Page 1.playgroundpage",
-                                                                                                       "Page 2.playgroundpage"
-                                                                                                     ])
-      end
-    end
-
-    it "calls the page_writer for each page" do
-      expect(page_writer).to receive(:write_page).with("Page 1", "Page 1.playgroundpage", [], "str = \"Yo, it's page 1.\"\nsharedFunc()")
-      expect(page_writer).to receive(:write_page).with("Page 2", "Page 2.playgroundpage", [], "str = \"Page 2 awww yeah.\"\nsharedFunc()")
-
-      collator.collate(chapter_name, parsed_chapter, [])
-    end
-
-    it "does not explode if a Source directory already exists" do
-      expect { collator.collate(chapter_name, parsed_chapter, []) }.to_not raise_error
-    end
-
-    context "having colated" do
-      before do
-        collator.collate(chapter_name, parsed_chapter, [])
-      end
-
-      it "creates a Source directory if one does not exist" do
-        expect(Dir.exist?("#{chapter_name}.playgroundchapter/#{SharedSourcesDirectoryName}")).to be_truthy
-      end
-
-      context "Sources folder" do
-        it "has a Preamble.swift file" do
-          expect(File.exist?("#{chapter_name}.playgroundchapter/#{SharedSourcesDirectoryName}/#{PreambleFileName}")).to be_truthy
-        end
-
-        it "has the correct preamble contents" do
-          expect(File.read("#{chapter_name}.playgroundchapter/#{SharedSourcesDirectoryName}/#{PreambleFileName}")).to eq("import UIKit\n\nvar str = \"Hello, playground\"\n\nfunc sharedFunc() {\n  print(\"This should be accessible to all pages.\")\n}")
-        end
-      end
-    end
-  end
-end

data/spec/renderer/contents_manfiest_generator_spec.rb

@@ -1,41 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-module Playgroundbook
-  describe ContentsManifestGenerator do
-    include FakeFS::SpecHelpers
-    let(:generator) { ContentsManifestGenerator.new(test_ui) }
-    let(:test_ui) { Cork::Board.new(silent: true) }
-
-    it "creates the manifest file" do
-      generator.generate(test_book_metadata)
-
-      expect(File.exist?("Manifest.plist")).to be_truthy
-    end
-
-    describe "the manifest file" do
-      before do
-        generator.generate(test_book_metadata)
-      end
-
-      it "has a book name" do
-        expect(get_manifest["Name"]).to eq("Testing Book")
-      end
-
-      it "has an identifier" do
-        expect(get_manifest["ContentIdentifier"]).to eq("com.ashfurrow.testing")
-      end
-
-      it "has a deployment target" do
-        expect(get_manifest["DeploymentTarget"]).to eq("ios10.0")
-      end
-
-      it "has chapters specified" do
-        expect(get_manifest["Chapters"]).to eq(["test_chapter.playgroundchapter"])
-      end
-
-      it "has a ImageReference" do
-        expect(get_manifest["ImageReference"]).to eq("file.jpeg")
-      end
-    end
-  end
-end