henshin 0.4.2 → 1.0.0.pre

data/spec/henshin/package_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../helper'
+
+describe Henshin::Package do
+
+  subject { Henshin::Package }
+
+  let(:compressor) { mock() }
+  let(:site) { test_site }
+  let(:package) { subject.new(site, compressor) }
+
+  describe '#text' do
+    it 'returns the compressed text if #enabled?' do
+      compressor.expects(:compress)
+      package.text
+    end
+
+    it 'returns the joined text when not #enabled?' do
+      package.stubs(:enabled?).returns(false)
+      compressor.expects(:join)
+      package.text
+    end
+  end
+
+end

data/spec/henshin/packages/script_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../../helper'
+
+describe Henshin::Package::Script do
+
+  let(:value) { Object.new }
+  let(:site)  { stub(:config => {compress: { scripts: value }}) }
+
+  subject     { Henshin::Package::Script }
+
+  describe '#enabled?' do
+    it 'uses value from site config' do
+      package = subject.new(site, [])
+      package.enabled?.must_equal value
+    end
+  end
+
+end

data/spec/henshin/packages/style_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../../helper'
+
+describe Henshin::Package::Style do
+
+  let(:value) { Object.new }
+  let(:site)  { stub(:config => {compress: {styles: value}}) }
+
+  subject     { Henshin::Package::Style }
+
+  describe '#enabled?' do
+    it 'uses value from site config' do
+      package = subject.new(site, [])
+      package.enabled?.must_equal value
+    end
+  end
+
+end

data/spec/henshin/path_spec.rb

@@ -0,0 +1,56 @@
+require_relative '../helper'
+require 'lib/henshin/path'
+
+describe Henshin::Path do
+
+  subject { Henshin::Path }
+
+  let(:root) { Pathname.new('/') }
+  let(:path) { subject.new(root, 'tag', 'code', 'index.html') }
+
+  it 'has an #extension' do
+    path.extension.must_equal '.html'
+  end
+
+  it 'has a #permalink' do
+    path.permalink.must_equal '/tag/code/index.html'
+  end
+
+  it 'has a #url' do
+    path.url.must_equal '/tag/code/'
+  end
+
+  it 'uses strict equality for #==' do
+    other = Henshin::Path(root, 'tag', 'code', 'index.html')
+    path.must_equal other
+  end
+
+  describe '#===' do
+    it 'matches permalink' do
+      path.must_be :===, '/tag/code/index.html'
+    end
+
+    it 'matches url' do
+      path.must_be :===, '/tag/code/'
+    end
+
+    it 'matches url without trailing slash' do
+      path.must_be :===, '/tag/code'
+    end
+
+    it 'matches equal Path' do
+      other = subject.new(root, 'tag', 'code', 'index.html')
+      path.must_be :===, other
+    end
+  end
+
+  it 'can #<<' do
+    path = subject.new(root, 'tag', 'code')
+    path << 'test.html'
+    path.must_be :===, '/tag/code/test.html'
+  end
+
+  it 'defines #Path()' do
+    Path(root, 'test').must_equal subject.new(root, 'test')
+  end
+end

data/spec/henshin/publisher_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../helper'
+
+describe Henshin::Publisher do
+
+  subject { Henshin::Publisher }
+
+  describe '.requires_keys' do
+    it 'returns true if the hash contains every key' do
+      hash = {a: 1, b: 2, c: 3}
+      list = [:a, :b]
+      subject.requires_keys(hash, list).must_equal true
+    end
+  end
+
+  describe '.get_required_opt' do
+    it 'returns the option' do
+      subject.get_required_opt({:a => 1}, :a).must_equal 1
+    end
+
+    it 'fails loudly' do
+      Henshin::UI.expects(:fail).with("Must give :a option to publish.")
+      subject.get_required_opt({}, :a)
+    end
+  end
+
+  describe '.get_password' do
+    it 'returns the password from the hash' do
+      subject.get_password({:pass => 'a'}, :pass).must_equal 'a'
+    end
+
+    it 'executes the command given' do
+      subject.get_password({:pass => '$sh echo "hello"'}, :pass).
+        must_equal 'hello'
+    end
+
+    it 'prompts for password' do
+      m = mock { expects(:ask) }
+      HighLine.expects(:new).returns(m)
+
+      subject.get_password({}, :pass)
+    end
+  end
+
+end

data/spec/henshin/publishers/sftp_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../../helper'
+
+describe Henshin::Publisher::Sftp do
+
+  subject { Henshin::Publisher::Sftp }
+
+  describe '#write' do
+
+    let(:path) { Pathname.new('cool/file.txt') }
+    let(:file) { mock.tap {|m| m.expects(:open).with("/#{path}", 'w') } }
+    let(:conn) { stub(:file => file, :lstat! => false) }
+
+    it 'writes the contents to the path' do
+      with_writing! do
+        sftp = subject.new(conn, Pathname.new('/'))
+        sftp.write path, 'Hey'
+      end
+    end
+
+  end
+end

data/spec/henshin/reader_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../helper'
+
+describe Henshin::Reader do
+
+  subject { Henshin::Reader.new(Pathname.new('site').realpath) }
+
+  def path(path)
+    Pathname.new('site').realpath + path
+  end
+
+  def paths(*path)
+    path.map {|i| path(i) }
+  end
+
+
+  describe '#ignore' do
+    it 'adds files to the ignored list' do
+      subject.ignore 'crazy-file.txt', 'another?.md'
+      subject.must_be :ignore?, path('crazy-file.txt')
+    end
+  end
+
+  describe '#ignore?' do
+    it 'checks if a file is in the ignored list' do
+      subject.must_be :ignore?, path('config.yml')
+    end
+
+    it 'checks if the file begins with an underscore' do
+      subject.must_be :ignore?, path('folder/folder/_file.txt')
+    end
+
+    it 'checks if a folder above begins with an underscore' do
+      subject.must_be :ignore?, path('folder/_folder/file.txt')
+    end
+  end
+
+  describe '#read' do
+    it 'finds all paths in path given' do
+      subject.read('**', '*.sass').must_equal paths('assets/styles/screen.sass')
+    end
+  end
+
+  describe '#read_all' do
+    it 'finds all paths under path given' do
+      subject.read_all('assets', 'styles').must_equal paths('assets/styles/screen.sass')
+    end
+  end
+
+  describe '#safe_paths' do
+    it 'finds all paths, excepts from reserved directories' do
+      subject.safe_paths.wont_include path('assets/styles/screen.sass')
+    end
+  end
+
+end

data/spec/henshin/safety_spec.rb

@@ -0,0 +1,66 @@
+require_relative '../helper'
+
+describe Henshin::Safety do
+
+  let(:klass) {
+    Class.new {
+      include Henshin::Safety
+
+      def unsafe_method; "Hey, I was called!"; end
+      unsafe :unsafe_method
+
+      def another(a, b, c); "Yes, called again"; end
+      unsafe :another
+
+      def safe_method; "Ok here"; end
+    }
+  }
+
+  subject { klass.new }
+
+  describe 'a normally created object including Safety' do
+    it 'can call marked methods normally' do
+      subject.unsafe_method.must_equal "Hey, I was called!"
+    end
+  end
+
+  describe '#safe' do
+    let(:unsafe) { subject }
+    let(:safe)   { unsafe.safe }
+
+    it 'returns a copy of the object' do
+      safe.wont_equal unsafe
+      safe.must_be_instance_of unsafe.class
+    end
+
+    it 'with the unsafe methods stubbed' do
+      safe.unsafe_method.must_equal nil
+    end
+
+    it 'works for methods expecting arguments' do
+      safe.another(1, 2, 3).must_equal nil
+    end
+
+    it 'unmarked methods still work' do
+      safe.safe_method.must_equal "Ok here"
+    end
+
+    it 'always returns the same safe clone' do
+      a = unsafe.safe
+      b = unsafe.safe
+      c = unsafe.safe
+
+      a.must_equal b
+      b.must_equal c
+    end
+  end
+
+  it 'infects inherited classes' do
+    subklass = Class.new(klass)
+    subsubject = subklass.new
+
+    subsubject.unsafe_method.must_equal "Hey, I was called!"
+    subsubject.safe.unsafe_method.must_equal nil
+  end
+
+end

data/spec/henshin/scope_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../helper'
+
+describe Henshin::Scope do
+
+  subject { Henshin::Scope }
+
+  describe '#initialize' do
+    it 'creates a method for each key-value' do
+      scope = subject.new a: 1, b: 2
+      scope.a.must_equal 1
+      scope.b.must_equal 2
+    end
+
+    it 'works recursively on hashes' do
+      scope = subject.new a: {b: {c: 3}}
+      scope.a.b.c.must_equal 3
+    end
+
+    it 'works on arrays of hashes' do
+      scope = subject.new a: [{b: 2}, {c: {d: 4}}]
+      scope.a[0].b.must_equal 2
+      scope.a[1].c.d.must_equal 4
+    end
+  end
+
+  describe '#method_missing' do
+    it 'returns nil for unknowns' do
+      scope = subject.new bye: 1
+      scope.hello.must_equal nil
+    end
+  end
+
+end

data/spec/henshin/site_spec.rb

@@ -0,0 +1,142 @@
+require_relative '../helper'
+
+describe Henshin::Site do
+
+  subject { Henshin::Site }
+  let(:site) { test_site }
+
+  describe '.file' do
+    it 'adds the file to the list' do
+      klass = subject.dup
+      klass.file :a, :b
+      klass.file_list.must_include :a
+      klass.file_list.must_include :b
+    end
+  end
+
+  describe '.files' do
+    it 'adds the files to the list' do
+      klass = subject.dup
+      klass.files :a, :b
+      klass.files_list.must_include :a
+      klass.files_list.must_include :b
+    end
+  end
+
+  describe '#initialize' do
+    let(:klass) {
+      k = subject.dup
+      k.any_instance.stubs(:config).returns({:ignore => 'a'})
+      k
+    }
+
+    it 'creates a reader' do
+      obj = klass.new(test_path)
+      obj.instance_variable_get(:@reader).must_be_kind_of Henshin::Reader
+    end
+
+    it 'sets the source' do
+      obj = klass.new(test_path.to_s)
+      obj.instance_variable_get(:@source).must_equal test_path
+    end
+
+    it 'sets ignored paths' do
+      obj = klass.new(test_path)
+      obj.instance_variable_get(:@reader).ignore?(test_path + 'a').must_equal true
+    end
+  end
+
+  describe '#dest' do
+    it 'returns the build path' do
+      site.dest.must_equal (Pathname.pwd + 'site' + 'build')
+    end
+
+    it 'uses the destination set in the config' do
+      site.stubs(:config).returns({:build => 'different'})
+      site.dest.must_equal (Pathname.pwd + 'site' + 'build')
+    end
+  end
+
+  describe '#root' do
+    it 'returns the url root' do
+      site.root.must_equal Pathname.new('/')
+    end
+  end
+
+  describe '#config' do
+    it 'combines the loaded config.yml with the defaults' do
+      site.config.author.must_equal "You"
+      site.config.md.superscript.must_equal true
+    end
+
+    it 'is a Hashie::Mash' do
+      site.config.must_be_kind_of Hashie::Mash
+    end
+  end
+
+  describe '#script' do
+    it 'returns the script package' do
+      site.script.must_be_kind_of Henshin::Package::Script
+    end
+  end
+
+  describe '#style' do
+    it 'returns the style package' do
+      site.style.must_be_kind_of Henshin::Package::Style
+    end
+  end
+
+  describe '#posts' do
+    it 'returns the posts' do
+      site.posts.all? {|p| p.kind_of?(Henshin::File::Post) }.must_equal true
+    end
+  end
+
+  describe '#files' do
+    it 'returns all other files' do
+      site.files.map(&:permalink).must_include '/index.html', '/feed.xml'
+    end
+  end
+
+  describe '#all_files' do
+    it 'returns all files' do
+      site.all_files.sort.must_equal [site.style, site.script, site.posts, site.files].flatten.sort
+    end
+  end
+
+  describe '#templates' do
+    it 'returns all templates' do
+      site.templates.map(&:name).must_include 'default', 'post'
+    end
+  end
+
+  describe '#method_missing' do
+    it 'gets the value from the yaml' do
+      site.author.must_equal "You"
+    end
+  end
+
+  describe '#write' do
+    it 'writes all the files' do
+      writer = Object.new
+      a, b = mock(:write => writer), mock(:write => writer)
+      site.expects(:all_files).returns([a, b])
+
+      site.write(writer)
+    end
+  end
+
+  describe '#template' do
+    it 'finds the template' do
+      default = site.template('default')
+      default.must_be_kind_of Henshin::File::Template
+      default.name.must_equal 'default'
+    end
+
+    it 'returns the EmptyTemplate if not found' do
+      temp = site.template('non-existent')
+      temp.must_be_kind_of Henshin::File::EmptyTemplate
+    end
+  end
+
+end