excalibur 0.0.2

data/spec/lib/excalibur/duplicator_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Excalibur
+  class Foo; include Duplicator; end
+
+  describe Duplicator do
+    let(:klass) { Foo.new }
+
+    describe '#dup_instance' do
+      context 'when input is a truncable content' do
+        let(:obj) { TruncateableContent.new }
+
+        it 'should call dup' do
+          expect( obj ).to receive(:dup)
+
+          klass.dup_instance(obj)
+        end
+      end
+
+      context 'when input is a hash' do
+        let(:obj) { ::HashWithIndifferentAccess.new }
+
+        it 'should call dup' do
+          expect( obj ).to receive(:deep_dup)
+
+          klass.dup_instance(obj)
+        end
+      end
+
+      context 'when input is a string' do
+        let(:obj) { 'foobar' }
+
+        it 'should not call dup' do
+          expect( obj ).to_not receive(:dup)
+
+          expect(klass.dup_instance(obj)).to eq('foobar')
+        end
+      end
+
+      context 'when input is nil' do
+        let(:obj) { nil }
+
+        it 'should not call dup' do
+          expect(klass.dup_instance(obj)).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/lib/excalibur/truncatable_content_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+module Excalibur
+  describe TruncateableContent do
+    describe '#new' do
+      let(:obj) { TruncateableContent.new }
+
+      it 'should create default content hash' do
+        expect(obj.content).to_not be_nil
+        expect(obj.content).to be_instance_of ::HashWithIndifferentAccess
+      end
+
+      it 'should create default options hash' do
+        expect(obj.options).to_not be_nil
+        expect(obj.options).to be_instance_of ::HashWithIndifferentAccess
+      end
+
+      it 'should create a default combinator' do
+        expect(obj.combinator).to be_nil
+      end
+    end
+
+    describe '#can_merge?' do
+      let(:obj) { TruncateableContent.new }
+
+      context 'when the objects are not the same' do
+        it 'should be false' do
+          expect(obj.can_merge?(true)).to eq(false)
+        end
+      end
+
+      context 'when the objects is the same' do
+        it 'should be true' do
+          expect(obj.can_merge?(obj)).to eq(true)
+        end
+      end
+    end
+
+    describe '#merge!' do
+      context 'when trying to merge with the wrong type of object' do
+        let(:obj) { TruncateableContent.new }
+
+        it 'should raise a TypeError' do
+          expect { obj.merge!('foo') }.to raise_error(TypeError, 'can only merge two Excalibur::TruncateableContent objects')
+        end
+      end
+
+      context 'when merging two correct object types' do
+        let(:obj_a) { TruncateableContent.new({body: 'foobar'}, {'body' => 'baz', other: true}, 'obj_a') }
+        let(:obj_b) { TruncateableContent.new({'body' => 'baz', other: true}, {body: 'foobar'}, 'obj_b') }
+
+        context 'function result' do
+          it 'should return the object' do
+            expect(obj_a.merge!(obj_b)).to be_instance_of TruncateableContent
+          end
+        end
+
+        context 'instance result' do
+          before do
+            obj_a.merge!(obj_b)
+          end
+
+          it 'should merge the content' do
+            expect(obj_a.content).to eq({'body' => 'baz', 'other' => true})
+          end
+
+          it 'should merge the options' do
+            expect(obj_a.options).to eq({'body' => 'foobar', 'other' => true})
+          end
+
+          it 'should overwrite the combinator' do
+            expect(obj_a.combinator).to eq('obj_b')
+          end
+
+          context 'when merging an object without combinator' do
+            let(:obj_b) { TruncateableContent.new({'body' => 'baz', other: true}, {body: 'foobar'}) }
+
+            it 'should not overwrite the combinator' do
+              expect(obj_a.combinator).to eq('obj_a')
+            end
+          end
+        end
+      end
+    end
+
+    describe '#dup' do
+      let(:obj) { TruncateableContent.new({body: 'foobar', other: proc { |obj| "proc content #{obj}" }}, {}, nil) }
+
+      it 'should create a duplicate of the object and the attributes' do
+        expect(obj).to receive(:dup_instance).exactly(3).times
+
+        obj.dup
+      end
+    end
+
+    describe '#get_content' do
+      let(:obj) { TruncateableContent.new(body: 'foobar', other: proc { |obj| "proc content #{obj}" }) }
+
+      it 'should return string content' do
+        expect(obj.get_content(:body)).to be_instance_of ::String
+        expect(obj.get_content(:body)).to eq('foobar')
+      end
+
+      it 'should return the result of proc content' do
+        expect(obj.get_content(:other, true)).to be_instance_of ::String
+        expect(obj.get_content(:other, true)).to eq('proc content true')
+      end
+    end
+
+    describe '#update_content' do
+      let(:obj) { TruncateableContent.new }
+
+      context 'when value is provided' do
+        it 'should add the content value' do
+          expect { obj.update_content(:body, 'Body content') }.to change(obj, :content)
+          expect(obj.content[:body]).to eq('Body content')
+        end
+      end
+
+      context 'when value has not been provided' do
+        it 'should add the content value' do
+          obj.update_content(:body)
+
+          expect(obj.content).to have_key(:body)
+          expect(obj.content[:body]).to be_nil
+        end
+      end
+    end
+
+    describe '#update_option' do
+      let(:obj) { TruncateableContent.new }
+
+      context 'when value is provided' do
+        it 'should add the option value' do
+          expect { obj.update_option(:limit, 88) }.to change(obj, :options)
+          expect(obj.options[:limit]).to eq(88)
+        end
+      end
+
+      context 'when value has not been provided' do
+        it 'should add the content value' do
+          obj.update_option(:limit)
+
+          expect(obj.options).to have_key(:limit)
+          expect(obj.options[:limit]).to be_nil
+        end
+      end
+    end
+
+    describe '#update_combinator' do
+      let(:obj) { TruncateableContent.new }
+
+      it 'should set the combinator' do
+        expect(obj.combinator).to be_nil
+
+        expect{ obj.update_combinator(proc { 'foobar' }) }.to change(obj, :combinator)
+
+        expect(obj.combinator).to be_instance_of(::Proc)
+        expect(obj.combinator.call).to eq('foobar')
+      end
+    end
+
+    describe '#render_long' do
+      let(:obj) { TruncateableContent.new(body: 'foobar', other: proc { |obj| "proc content #{obj}" }) }
+
+      it 'should render all the values of the content hash' do
+        expect(obj.render_long(true)).to be_instance_of ::String
+        expect(obj.render_long(true)).to eq('foobarproc content true')
+      end
+    end
+
+    describe '#render_short' do
+      context 'when a combinator is a proc' do
+        let(:obj) { TruncateableContent.new({}, {}, proc { |obj| "obj: #{obj}" }) }
+
+        it 'should call the proc with the given object' do
+          expect(obj.render_short(true)).to eq('obj: true')
+        end
+      end
+
+      context 'when a combinator is not a proc' do
+        let(:obj) { TruncateableContent.new() }
+
+        it 'should call for render_long' do
+          expect(obj).to receive(:render_long).with(true)
+
+          obj.render_short(true)
+        end
+      end
+    end
+  end
+end

data/spec/lib/excalibur/view_helper_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'excalibur/view_helpers'
+require 'action_view/helpers'
+
+class Dummy; end
+class Klass; end
+
+module Excalibur
+  class DummyDecorator < Decorator; end
+
+  describe ViewHelpers do
+    let(:helpers) do
+      klass = Klass.new.extend(ActionView::Helpers::TagHelper)
+      klass.extend(ViewHelpers)
+    end
+
+    describe '#entitle' do
+      let(:obj) { Dummy.new }
+
+      it 'should try and decorate an object' do
+        expect(DummyDecorator).to receive(:decorate).with(obj, {})
+
+        helpers.entitle(obj, {})
+      end
+
+      it 'should set an instance variable' do
+        helpers.entitle(obj, {})
+
+        expect(helpers.instance_variable_get(:@excalibur_subject)).to be_present
+        expect(helpers.instance_variable_get(:@excalibur_subject)).to be_instance_of DummyDecorator
+      end
+    end
+
+    describe '#render_title_tag' do
+      context 'when the configuration is standard' do
+        it 'should return a title tag with the default content' do
+          expect(helpers.render_title_tag).to eq '<title>Excalibur</title>'
+        end
+      end
+
+      context 'when the configuration changed' do
+        before do
+          DummyDecorator.excalibur_set_title_content :body, 'New custom title'
+          DummyDecorator.excalibur_set_title_content :prefix, '()==|::::::> '
+
+          helpers.entitle(Dummy.new)
+        end
+
+        it 'should return a title tag with the custom title content' do
+          expect(helpers.render_title_tag).to eq '<title>()==|::::::&gt; New custom title</title>'
+        end
+      end
+    end
+
+    describe '#render_meta_tags' do
+      context 'when the configuration is standard' do
+        it 'should return a set of meta tags with the default content' do
+          expect(helpers.render_meta_tags).to include '<meta content="Excalibur; a worthy title for a gem about titles." name="description" />'
+          expect(helpers.render_meta_tags).to include '<meta content="width=device-width, initial-scale=1" name="viewport" />'
+        end
+      end
+
+      context 'when the configuration changed' do
+        before do
+          DummyDecorator.excalibur_set_description_content :body, 'New custom description'
+          DummyDecorator.excalibur_set_meta_tag :foo, :bar, 'baz'
+          DummyDecorator.excalibur_set_meta_tag :foo, :array, ['foo', 'bar', 'baz']
+          DummyDecorator.excalibur_set_meta_tag :foo, :proc, proc { |obj| obj.class.to_s }
+          DummyDecorator.excalibur_set_meta_tag :foo, :nil, nil
+
+          helpers.entitle(Dummy.new)
+        end
+
+        it 'should return a title tag with the custom title content' do
+          expect(helpers.render_meta_tags).to include '<meta content="New custom description" name="description" />'
+          expect(helpers.render_meta_tags).to include '<meta content="width=device-width, initial-scale=1" name="viewport" />'
+          expect(helpers.render_meta_tags).to include '<meta content="baz" foo="bar" />'
+          expect(helpers.render_meta_tags).to include '<meta content="foo" foo="array" />'
+          expect(helpers.render_meta_tags).to include '<meta content="bar" foo="array" />'
+          expect(helpers.render_meta_tags).to include '<meta content="baz" foo="array" />'
+          expect(helpers.render_meta_tags).to include '<meta content="Excalibur::DummyDecorator" foo="proc" />'
+          expect(helpers.render_meta_tags).to_not include 'foo="nil" />'
+        end
+      end
+    end
+  end
+end

data/spec/lib/excalibur_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module Excalibur
+  describe '::configure' do
+    context 'when the config is empty' do
+      let(:obj) { Decorator.new(true) }
+
+      before do
+        Excalibur.configure {}
+      end
+
+      it 'should create a configuration' do
+        expect(Excalibur.configuration).to be_present
+        expect(Excalibur.configuration).to be_instance_of Configuration
+      end
+
+      it 'should set the config default objects' do
+        expect(Excalibur.configuration.title).to be_instance_of TruncateableContent
+        expect(Excalibur.configuration.description).to be_instance_of TruncateableContent
+        expect(Excalibur.configuration.meta_tags).to be_instance_of ::HashWithIndifferentAccess
+      end
+
+      it 'should have the correct title value' do
+        expect(Excalibur.configuration.title.to_s(obj)).to eq('Excalibur')
+      end
+
+      it 'should have the correct description value' do
+        expect(Excalibur.configuration.description.to_s(obj)).to eq('Excalibur; a worthy title for a gem about titles.')
+      end
+
+      after do
+        Excalibur.reset
+      end
+    end
+
+    context 'when the config is contains changes' do
+      before do
+        Excalibur.configure do |config|
+          config.title = 'Foobar'
+        end
+      end
+
+      it 'should set the config default objects' do
+        expect(Excalibur.configuration.description).to be_instance_of TruncateableContent
+        expect(Excalibur.configuration.meta_tags).to be_instance_of ::HashWithIndifferentAccess
+      end
+
+      it 'should have the changed title' do
+        expect(Excalibur.configuration.title).to be_instance_of ::String
+        expect(Excalibur.configuration.title.to_s).to eq('Foobar')
+      end
+
+      after do
+        Excalibur.reset
+      end
+    end
+  end
+
+  describe '::configuration' do
+    before do
+      @config = Excalibur.configuration
+    end
+
+    it 'should create only one new' do
+      expect(Configuration).to_not receive(:new)
+      expect(Excalibur.configuration).to eq(@config)
+    end
+  end
+
+  describe '::reset' do
+    before do
+      Excalibur.configure do |config|
+        config.title = 'Foobar'
+      end
+    end
+
+    it 'should set the config value' do
+      @old = Excalibur.configuration
+
+      Excalibur.reset
+
+      expect(Excalibur.configuration.title).to_not equal(@old.title)
+    end
+  end
+end

data/spec/lib/generators/excalibur/decorator_generator_spec.rb

@@ -0,0 +1,28 @@
+require 'generator_spec'
+require 'generators/excalibur/decorator_generator'
+
+module Excalibur
+  describe Generators::DecoratorGenerator do
+    destination File.expand_path('../../tmp', __FILE__)
+    arguments %w(dummy)
+
+    before(:all) do
+      prepare_destination
+      run_generator
+    end
+
+    it 'should create the correct file and content' do
+      expect(destination_root).to have_structure {
+        directory 'app' do
+          directory 'decorators' do
+            directory 'excalibur' do
+              file 'dummy_decorator.rb' do
+                contains 'class Excalibur::DummyDecorator < Excalibur::Decorator'
+              end
+            end
+          end
+        end
+      }
+    end
+  end
+end

data/spec/lib/generators/excalibur/install_generator_spec.rb

@@ -0,0 +1,30 @@
+require 'generator_spec'
+require 'generators/excalibur/install_generator'
+
+module Excalibur
+  describe Generators::InstallGenerator do
+    destination File.expand_path('../../tmp', __FILE__)
+
+    before(:all) do
+      prepare_destination
+      run_generator
+    end
+
+    it 'creates a test initializer' do
+      assert_file 'config/initializers/excalibur.rb'
+    end
+
+    it 'should copy the template initializer over to the app config' do
+      expect(destination_root).to have_structure {
+        no_file 'excalibur.rb'
+        directory 'config' do
+          directory 'initializers' do
+            file 'excalibur.rb' do
+              contains 'Excalibur.configure do |config|'
+            end
+          end
+        end
+      }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,80 @@
+require 'excalibur'
+require 'pry'
+require 'simplecov'
+
+SimpleCov.start
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+end