middleman-presentation-core 0.16.0.alpha

data/spec/frontend_component_spec.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe FrontendComponent do
+  context '#initialize' do
+    it 'supports a full url as resource locator' do
+      expect do
+        FrontendComponent.new(resource_locator: 'http://www.example.org/test')
+      end.not_to raise_error
+    end
+
+    it 'fails if neither github nor resource_locator is given' do
+      expect do
+        FrontendComponent.new
+      end.to raise_error ArgumentError
+    end
+
+    it 'build github url' do
+      expect do
+        FrontendComponent.new(github: 'example/example')
+      end.not_to raise_error
+    end
+
+    it 'fails if name is empty when extracted from url' do
+      expect do
+        FrontendComponent.new(resource_locator: 'http://www.example.org')
+      end.to raise_error ArgumentError
+    end
+
+    it 'requires name if version is given' do
+      expect do
+        FrontendComponent.new(version: '1.1.1', name: 'blub')
+      end.not_to raise_error
+    end
+
+    it 'fails if version is given but no name' do
+      expect do
+        FrontendComponent.new(version: '1.1.1')
+      end.to raise_error ArgumentError
+    end
+  end
+
+  context '#name' do
+    it 'extracts name from url' do
+      component = FrontendComponent.new(resource_locator: 'http://example.org/test')
+      expect(component.name).to eq 'test'
+    end
+
+    it 'uses name' do
+      component = FrontendComponent.new(resource_locator: 'http://example.org/test', name: 'name')
+      expect(component.name).to eq 'name'
+    end
+  end
+
+  context '#resource_locator' do
+    it 'uses version as resource_locator' do
+      component = FrontendComponent.new(name: 'asdf', version: '0.0.1')
+      expect(component.resource_locator).to eq '0.0.1'
+    end
+
+    it 'uses url as resource_locator' do
+      component = FrontendComponent.new(resource_locator: 'http://example.org/test')
+      expect(component.resource_locator).to eq 'http://example.org/test'
+    end
+
+    it 'uses github repository as resource_locator' do
+      component = FrontendComponent.new(github: 'example.org/test')
+      expect(component.resource_locator).to eq 'https://github.com/example.org/test.git'
+    end
+  end
+
+  context '#path' do
+    it 'is root directory + name' do
+      root_directory = absolute_path('test.d')
+      name = 'test'
+
+      component = FrontendComponent.new(name: name, version: 'latest')
+      component.root_directory = root_directory
+
+      expect(component.path).to eq Pathname.new(File.join(root_directory, name))
+    end
+  end
+
+  context '#base_path' do
+    it 'returns the path of frontend component without name' do
+      root_directory = absolute_path('test.d')
+
+      component = FrontendComponent.new(name: 'test', version: 'latest')
+      component.root_directory = root_directory
+
+      expect(component.base_path).to eq Pathname.new(root_directory)
+    end
+  end
+end

data/spec/helpers_manager_spec.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe HelpersManager do
+  let(:helpers_module) do
+    Module.new do
+      def helper1
+        'helper1'
+      end
+    end
+  end
+
+  context '#add' do
+    it 'let you add modules' do
+      stub_const('HelpersModule', helpers_module)
+
+      manager = HelpersManager.new
+      manager.add HelpersModule
+    end
+
+    it 'let you add procs' do
+      manager = HelpersManager.new
+      manager.add do
+        def helper1
+          'helper1'
+        end
+      end
+    end
+  end
+
+  context '#available_helpers' do
+    it 'returns a module' do
+      manager = HelpersManager.new
+      manager.add do
+        def helper1
+          'helper1'
+        end
+      end
+
+      expect(manager.available_helpers).to be_kind_of Module
+    end
+
+    it 'the returned module has all methods in there' do
+      manager = HelpersManager.new
+      manager.add do
+        def helper1
+          'helper1'
+        end
+      end
+
+      local_module = Module.new do
+        extend manager.available_helpers
+      end
+
+      expect(local_module.helper1).to eq 'helper1'
+    end
+  end
+
+  context '#to_s' do
+    it 'returns a string representation of self' do
+      stub_const('HelpersModule', helpers_module)
+
+      manager = HelpersManager.new
+      manager.add HelpersModule
+      manager.add do
+        def helper2
+          'helper2'
+        end
+
+        def helper3
+          'helper3'
+        end
+
+        def self.helper4
+          'helper4'
+        end
+      end
+
+      expect(manager.to_s).to eq <<-EOS.strip_heredoc.chomp
+        +---------------+--------+--------------------------------------+
+        | Name          | Type   | Available methods                    |
+        +---------------+--------+--------------------------------------+
+        | <Anonymous>   | PROC   | "helper2", "helper3", "self.helper4" |
+        | HelpersModule | MODULE | "helper1"                            |
+        +---------------+--------+--------------------------------------+
+        2 rows in set
+      EOS
+    end
+  end
+end

data/spec/ignore_file_spec.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe IgnoreFile do
+  context '#initialize' do
+    it 'succeeds if path is given' do
+      expect do
+        file = touch_file('ignore_file')
+        IgnoreFile.new absolute_path(file)
+      end.not_to raise_error
+    end
+
+    it 'fails if path is missing' do
+      expect do
+        IgnoreFile.new
+      end.to raise_error ArgumentError
+    end
+
+    context '#ignore?' do
+      it 'checks if slide can be ignored' do
+        slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+        allow(slide1).to receive(:match?).and_return(false)
+        allow(slide1).to receive(:match?).with(/(?-mix:^!$)|(?-mix:01)/).and_return(true)
+
+        slide2 = instance_double('Middleman::Presentation::ExistingSlide')
+        allow(slide2).to receive(:match?).and_return(false)
+
+        file = write_file 'ignore_file', <<-EOS.strip_heredoc
+        01
+        EOS
+
+        ignore_file = IgnoreFile.new(absolute_path(file))
+
+        expect(ignore_file).to be_ignore slide1
+        expect(ignore_file).not_to be_ignore slide2
+      end
+
+      it 'strips off full line comments' do
+        slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+        allow(slide1).to receive(:match?).with(/(?-mix:^!$)|(?-mix:02)/).and_return(false)
+
+        path = write_file 'ignore_file', <<-EOS.strip_heredoc
+        # 01
+        02
+        EOS
+
+        file = IgnoreFile.new(path)
+
+        expect(file).not_to be_ignore slide1
+      end
+
+      it 'strips off line comments' do
+        slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+        allow(slide1).to receive(:match?).and_return(false)
+        allow(slide1).to receive(:match?).with(/(?-mix:^!$)|(?-mix:01)/).and_return(true)
+
+        file = write_file 'ignore_file', <<-EOS.strip_heredoc
+        01 # hello world
+        EOS
+
+        ignore_file = IgnoreFile.new(absolute_path(file))
+
+        expect(ignore_file).to be_ignore slide1
+      end
+
+      it 'handles non existing ignore file' do
+        slide1 = instance_double('Middleman::Presentation::ExistingSlide')
+
+        file = IgnoreFile.new SecureRandom.hex
+
+        expect(file).not_to be_ignore slide1
+      end
+    end
+  end
+end

data/spec/new_slide_spec.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe NewSlide do
+
+  context '#<=>' do
+    it 'compares slides with same file name' do
+      slide1 = NewSlide.new('01.md', base_path: absolute_path('source', 'slides'))
+      slide2 = NewSlide.new('01.md', base_path: absolute_path('source', 'slides'))
+
+      expect(slide1).to eq slide2
+    end
+
+    it 'compares slides with different file names' do
+      slide1 = NewSlide.new('01.erb', base_path: absolute_path('source', 'slides'))
+      slide2 = NewSlide.new('01.md', base_path: absolute_path('source', 'slides'))
+
+      expect(slide1).not_to eq slide2
+    end
+
+    it 'compares slides with not extension at all' do
+      slide1 = NewSlide.new('01', base_path: absolute_path('source', 'slides'))
+      slide2 = NewSlide.new('01', base_path: absolute_path('source', 'slides'))
+
+      expect(slide1).to eq slide2
+    end
+  end
+
+  context '#eql?' do
+    it 'succeeds on eqal file names' do
+      slide1 = NewSlide.new('01.erb', base_path: absolute_path('source', 'slides'))
+      slide2 = NewSlide.new('01.erb', base_path: absolute_path('source', 'slides'))
+
+      expect(slide1.eql?(slide2)).to be_truthy
+    end
+
+    it 'fails on different names' do
+      slide1 = NewSlide.new('01.erb', base_path: absolute_path('source', 'slides'))
+      slide2 = NewSlide.new('02.erb', base_path: absolute_path('source', 'slides'))
+
+      expect(slide1.eql?(slide2)).to be_falsey
+    end
+  end
+
+  context '#similar?' do
+    it 'succeeds if both files share the same basename' do
+      slide1 = NewSlide.new('01.erb', base_path: absolute_path('source', 'slides'))
+      slide2 = NewSlide.new('01.md', base_path: absolute_path('source', 'slides'))
+
+      expect(slide1).to be_similar slide2
+    end
+
+    it 'fails if both files do not share the same basename' do
+      slide1 = NewSlide.new('01.erb', base_path: absolute_path('source', 'slides'))
+      slide2 = NewSlide.new('02.erb', base_path: absolute_path('source', 'slides'))
+
+      expect(slide1).not_to be_similar slide2
+    end
+  end
+
+  context '#hash' do
+    it 'generates hash based on file name' do
+      slide = NewSlide.new('01.erb', base_path: absolute_path('source', 'slides'))
+      expect(slide).to respond_to :hash
+    end
+  end
+
+  context '#content' do
+    it 'evaluates template with data' do
+      slide = NewSlide.new('01.erb', base_path: absolute_path('source', 'slides'))
+
+      expect(slide.content(title: 'world')).to eq <<-EOS.strip_heredoc.chomp
+      <section>
+        <h1>
+          world
+        </h1>
+      </section>
+      EOS
+    end
+  end
+
+  context '#write' do
+    it 'writes content of slide to filesystem' do
+      slide = NewSlide.new('01.erb', base_path: absolute_path('source', 'slides'))
+      slide.write(title: 'world')
+
+      in_current_dir do
+        slide_content = File.read('source/slides/01.html.erb')
+
+        expect(slide_content).to eq <<-EOS.strip_heredoc.chomp
+        <section>
+          <h1>
+            world
+          </h1>
+        </section>
+        EOS
+      end
+    end
+  end
+
+  context '#to_s' do
+    it 'returns string representation of self' do
+      slide = NewSlide.new('02.md', base_path: absolute_path('source', 'slides'))
+
+      expect(slide.to_s).to eq absolute_path('source', 'slides', '02.html.md')
+    end
+  end
+
+  context '#basename' do
+    it 'reduces slide file name to minimum' do
+      slide = NewSlide.new('02.erb', base_path: absolute_path('source', 'slides'))
+      expect(slide.base_name).to eq '02'
+    end
+  end
+
+  context '#match?' do
+    it 'matches relative path' do
+      slide = NewSlide.new('02.md', base_path: absolute_path('source', 'slides'))
+
+      expect(slide).to be_match(/02/)
+    end
+
+    it 'supports string' do
+      slide = NewSlide.new('02.md', base_path: absolute_path('source', 'slides'))
+
+      expect(slide).to be_match('02')
+    end
+  end
+
+  context '#group?' do
+    it 'succeeds if slide has group' do
+      slide = NewSlide.new('group:02.md', base_path: absolute_path('source', 'slides'))
+
+      expect(slide).to be_group 'group'
+    end
+
+    it 'succeeds if slide has group and no ending' do
+      slide = NewSlide.new('group:02', base_path: absolute_path('source', 'slides'))
+
+      expect(slide).to be_group 'group'
+    end
+
+    it 'succeeds if slide has same name for group and slide' do
+      slide = NewSlide.new('02:02', base_path: absolute_path('source', 'slides'))
+
+      expect(slide).to be_group '02'
+    end
+
+    it 'fails if slide has not group' do
+      slide = NewSlide.new('02.md', base_path: absolute_path('source'))
+
+      expect(slide).not_to be_group 'group'
+    end
+  end
+end

data/spec/presentation_helper_spec.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe PresentationHelper do
+  let(:helpers_module) do
+    Module.new do
+      def helper1
+        'helper1'
+      end
+    end
+  end
+
+  context '#initialize' do
+    it 'accepts a module' do
+      stub_const('HelpersModule', helpers_module)
+      expect { PresentationHelper.new HelpersModule }.not_to raise_error
+    end
+
+    it 'accepts a block' do
+      expect { PresentationHelper.new(proc { def helper1; end }) }.not_to raise_error
+    end
+
+    it 'fails on other types' do
+      expect { PresentationHelper.new('') }.to raise_error TypeError
+    end
+  end
+
+  context '.parse' do
+    it 'creates helper from array of modules' do
+      helpers_module1 = Module.new do
+        def helper1
+          'helper1'
+        end
+      end
+
+      helpers_module2 = Module.new do
+        def helper2
+          'helper2'
+        end
+      end
+
+      stub_const('HelpersModule1', helpers_module1)
+      stub_const('HelpersModule2', helpers_module2)
+
+      helpers = PresentationHelper.parse [HelpersModule1, HelpersModule2]
+
+      expect(helpers.size).to eq 2
+      expect(helpers.first.available_methods).to eq [:helper1]
+      expect(helpers.last.available_methods).to eq [:helper2]
+    end
+
+    it 'creates helper from array of procs' do
+      proc1 = proc { def helper1; end }
+      proc2 = proc do
+        def helper2; end
+      end
+
+      helpers = PresentationHelper.parse [proc1, proc2]
+
+      expect(helpers.size).to eq 2
+      expect(helpers.first.available_methods).to eq [:helper1]
+      expect(helpers.last.available_methods).to eq [:helper2]
+    end
+
+    it 'supports mixed arrays' do
+      stub_const('HelpersModule', helpers_module)
+      proc2 = proc { def helper2; end }
+
+      helpers = PresentationHelper.parse [HelpersModule, proc2]
+
+      expect(helpers.size).to eq 2
+      expect(helpers.first.available_methods).to eq [:helper1]
+      expect(helpers.last.available_methods).to eq [:helper2]
+    end
+  end
+
+  context '#to_module' do
+    it 'returns self as module' do
+      stub_const('HelpersModule', helpers_module)
+      helper = PresentationHelper.new HelpersModule
+
+      expect(helper.to_module).to be_kind_of Module
+    end
+
+    it 'transforms if block was given' do
+      helper = PresentationHelper.new(proc { def helper1; end })
+
+      expect(helper.to_module).to be_kind_of Module
+    end
+  end
+
+  context '#name' do
+    it 'returns name' do
+      stub_const('HelpersModule', helpers_module)
+      helper = PresentationHelper.new HelpersModule
+
+      expect(helper.name).to eq 'HelpersModule'
+    end
+
+    it 'returns anonymous if unkown' do
+      helper = PresentationHelper.new proc { def helper1; end }
+
+      expect(helper.name).to eq '<Anonymous>'
+    end
+  end
+
+  context '#type' do
+    it 'returns module if module was given' do
+      stub_const('HelpersModule', helpers_module)
+      helper = PresentationHelper.new HelpersModule
+
+      expect(helper.type).to eq :MODULE
+    end
+
+    it 'returns proc if proc was given' do
+      helper = PresentationHelper.new proc { def helper1; end }
+
+      expect(helper.type).to eq :PROC
+    end
+  end
+
+  context '#available_methods' do
+    it 'extracts methods if module was given' do
+      stub_const('HelpersModule', helpers_module)
+      helper = PresentationHelper.new HelpersModule
+
+      expect(helper.available_methods).to eq [:helper1]
+    end
+
+    it 'extracts methods if proc was given' do
+      helper = PresentationHelper.new proc { def helper1; end }
+
+      expect(helper.available_methods).to eq [:helper1]
+    end
+
+  end
+end

data/spec/slide_group_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+require 'spec_helper'
+
+RSpec.describe SlideGroup do
+  let(:template) { double('Template') }
+  let(:slide1) { instance_double('Middleman::Presentation::ExistingSlide') }
+  let(:slide2) { instance_double('Middleman::Presentation::ExistingSlide') }
+
+  context '#initialize' do
+    it 'requires a name, slides and template' do
+      expect do
+        SlideGroup.new(name: 'group', slides: [slide1, slide2], template: template)
+      end.not_to raise_error
+    end
+  end
+
+  context '#partial_path' do
+    it 'returns path to group file' do
+      expect(slide1).to receive(:partial_path).and_return 'path1'
+      expect(slide2).to receive(:partial_path).and_return 'path2'
+
+      group = SlideGroup.new(name: 'group', slides: [slide1, slide2], template: template)
+
+      expect(group.partial_path).to eq '"path1", "path2"'
+    end
+  end
+
+  context '#slides' do
+    it 'returns slides belonging to group' do
+      group = SlideGroup.new(name: 'group', slides: [slide1, slide2], template: template)
+      expect(group.slides).to include slide1, slide2
+    end
+  end
+
+  context '#name' do
+    it 'returns name of group' do
+      group = SlideGroup.new(name: 'group', slides: [slide1, slide2], template: template)
+      expect(group.name).to eq 'group'
+    end
+  end
+
+  context '#renders' do
+    it 'renders slides and uses template' do
+      block = proc { |_partial_path| }
+
+      expect(slide1).to receive(:render) { |&passed_block| expect(block).to be passed_block }.and_return('01')
+      expect(slide2).to receive(:render) { |&passed_block| expect(block).to be passed_block }.and_return('02')
+      expect(template).to receive(:result).with(slides: "01\n02")
+
+      group = SlideGroup.new(name: 'group', slides: [slide1, slide2], template: template)
+      group.render(&block)
+    end
+  end
+end