alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/javascripts/helpers/test_responses/test_responses.js

@@ -1 +0,0 @@
-var TestResponses = {};

data/spec/javascripts/support/jasmine.yml

@@ -1,29 +0,0 @@
-# path to parent directory of src_files
-# relative path from Rails.root
-# defaults to app/assets/javascripts
-src_dir: "app/assets/javascripts"
-
-# list of file expressions to include as source files
-# relative path from src_dir
-src_files:
- - "application.{js,coffee}"
-
-# path to parent directory of spec_files
-# relative path from Rails.root
-# defaults to spec/javascripts
-spec_dir: spec/javascripts
-
-# list of file expressions to include as helpers into spec runner
-# relative path from spec_dir
-helpers:
-  - "helpers/**/*.{js,coffee}"
-
-# list of file expressions to include as specs into spec runner
-# relative path from spec_dir
-spec_files:
-  - "**/*[Ss]pec.{js,coffee}"
-
-# path to directory of temporary files
-# (spec runner and asset cache)
-# defaults to spec/tmp
-tmp_dir: "spec/tmp"

data/spec/libraries/auth_accessors_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  class MyCustomUser
-  end
-
-  describe 'AuthAccessors' do
-    describe '.user_class' do
-      before do
-        # prevent memoization
-        Alchemy.class_variable_set('@@user_class', nil)
-      end
-
-      it "raises error if user_class_name is not a String" do
-        Alchemy.user_class_name = MyCustomUser
-        expect {
-          Alchemy.user_class
-        }.to raise_error(TypeError)
-      end
-
-      after do
-        Alchemy.user_class_name = 'DummyUser'
-      end
-    end
-
-    describe 'defaults' do
-      it 'has default value for Alchemy.signup_path' do
-        expect(Alchemy.signup_path).to eq('/signup')
-      end
-
-      it 'has default value for Alchemy.login_path' do
-        expect(Alchemy.login_path).to eq('/login')
-      end
-
-      it 'has default value for Alchemy.logout_path' do
-        expect(Alchemy.logout_path).to eq('/logout')
-      end
-    end
-  end
-end

data/spec/libraries/config_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Config do
-    describe ".get" do
-      it "should call #show" do
-        expect(Config).to receive(:show).and_return({})
-        Config.get(:mailer)
-      end
-
-      it "should return the requested part of the config" do
-        expect(Config).to receive(:show).and_return({'mailer' => {'setting' => 'true'}})
-        expect(Config.get(:mailer)).to eq({'setting' => 'true'})
-      end
-    end
-
-    describe '.main_app_config' do
-      let(:main_app_config_path) { "#{Rails.root}/config/alchemy/config.yml" }
-
-      it "should call and return .read_file with the correct config path" do
-        expect(Config).to receive(:read_file).with(main_app_config_path).once.and_return({setting: 'true'})
-        expect(Config.send(:main_app_config)).to eq({setting: 'true'})
-      end
-    end
-
-    describe '.env_specific_config' do
-      let(:env_specific_config_path) { "#{Rails.root}/config/alchemy/#{Rails.env}.config.yml" }
-
-      it "should call and return .read_file with the correct config path" do
-        expect(Config).to receive(:read_file).with(env_specific_config_path).once.and_return({setting: 'true'})
-        expect(Config.send(:env_specific_config)).to eq({setting: 'true'})
-      end
-    end
-
-    describe ".show" do
-      context "when ivar @config was not set before" do
-        before { Config.instance_variable_set("@config", nil) }
-
-        it "should call and return .merge_configs!" do
-          expect(Config).to receive(:merge_configs!).once.and_return({setting: 'true'})
-          expect(Config.show).to eq({setting: 'true'})
-        end
-      end
-
-      context "when ivar @config was already set" do
-        before { Config.instance_variable_set("@config", {setting: 'true'}) }
-        after { Config.instance_variable_set("@config", nil) }
-
-        it "should have memoized the return value of .merge_configs!" do
-          expect(Config.send(:show)).to eq({setting: 'true'})
-        end
-      end
-    end
-
-    describe '.read_file' do
-      context 'when given path to yml file exists' do
-        before { allow(File).to receive(:exist?).and_return(true) }
-
-        it 'should call YAML.load_file with the given config path' do
-          expect(YAML).to receive(:load_file).once.with('path/to/config.yml').and_return({})
-          Config.send(:read_file, 'path/to/config.yml')
-        end
-
-        context 'but its empty' do
-          before do
-            allow(File).to receive(:exist?).with('empty_file.yml').and_return(true)
-            allow(YAML).to receive(:load_file).and_return(false) # YAML.load_file returns false if file is empty.
-          end
-
-          it "should return an empty Hash" do
-            expect(Config.send(:read_file, 'empty_file.yml')).to eq({})
-          end
-        end
-      end
-
-      context 'when given path to yml file does not exist' do
-        it 'should return an empty Hash' do
-          expect(Config.send(:read_file, 'does/not/exist.yml')).to eq({})
-        end
-      end
-    end
-
-    describe '.merge_configs!' do
-      let(:config_1) do
-        {setting_1: 'same', other_setting: 'something'}
-      end
-
-      let(:config_2) do
-        {setting_1: 'same', setting_2: 'anything'}
-      end
-
-      it "should stringify the keys" do
-        expect(Config.send(:merge_configs!, config_1)).to eq(config_1.stringify_keys!)
-      end
-
-      context 'when all passed configs are empty' do
-        it "should raise an error" do
-          expect { Config.send(:merge_configs!, {}) }.to raise_error(LoadError)
-        end
-      end
-
-      context 'when configs containing same keys' do
-        it "should merge them together" do
-          expect(Config.send(:merge_configs!, config_1, config_2)).to eq(
-            {'setting_1' => 'same', 'other_setting' => 'something', 'setting_2' => 'anything'}
-          )
-        end
-      end
-    end
-  end
-end

data/spec/libraries/controller_actions_spec.rb

@@ -1,133 +0,0 @@
-require 'spec_helper'
-
-# Here's a tiny custom matcher making it a bit easier to check the
-# current session for a language configuration.
-#
-RSpec::Matchers.define :include_language_information_for do |expected|
-  match do |actual|
-    actual[:alchemy_language_id] == expected.id
-  end
-end
-
-describe 'Alchemy::ControllerActions', type: 'controller' do
-  # Anonymous controller to test the integration against
-  controller(ActionController::Base) do
-    include Alchemy::ControllerActions
-  end
-
-  describe "#current_alchemy_user" do
-    context "with default current_user_method" do
-      it "calls current_user by default" do
-        expect(controller).to receive :current_user
-        controller.send :current_alchemy_user
-      end
-    end
-
-    context "with custom current_user_method" do
-      before do
-        Alchemy.current_user_method = 'current_admin'
-      end
-
-      it "calls the custom method" do
-        expect(controller).to receive :current_admin
-        controller.send :current_alchemy_user
-      end
-    end
-
-    context "with not implemented current_user_method" do
-      before do
-        Alchemy.current_user_method = 'not_implemented_method'
-      end
-
-      after do
-        Alchemy.current_user_method = 'current_user'
-      end
-
-      it "raises an error" do
-        expect{
-          controller.send :current_alchemy_user
-        }.to raise_error(Alchemy::NoCurrentUserFoundError)
-      end
-    end
-  end
-
-  describe "#set_alchemy_language" do
-    let(:default_language) { Alchemy::Language.default }
-    let(:klingon)          { create(:alchemy_language, :klingon) }
-
-    after do
-      # We must never change the app's locale
-      expect(::I18n.locale).to eq(:en)
-    end
-
-    context "with a Language argument" do
-      it "should set the language to the passed Language instance" do
-        controller.send :set_alchemy_language, klingon
-        expect(assigns(:language)).to eq(klingon)
-        expect(Alchemy::Language.current).to eq(klingon)
-      end
-    end
-
-    context "with a language id argument" do
-      it "should set the language to the language specified by the passed id" do
-        controller.send :set_alchemy_language, klingon.id
-        expect(assigns(:language)).to eq(klingon)
-        expect(Alchemy::Language.current).to eq(klingon)
-      end
-    end
-
-    context "with a language code argument" do
-      it "should set the language to the language specified by the passed code" do
-        controller.send :set_alchemy_language, klingon.code
-        expect(assigns(:language)).to eq(klingon)
-        expect(Alchemy::Language.current).to eq(klingon)
-      end
-    end
-
-    context "with no lang param" do
-      it "should set the default language" do
-        allow(controller).to receive(:params).and_return({})
-        controller.send :set_alchemy_language
-        expect(assigns(:language)).to eq(default_language)
-        expect(Alchemy::Language.current).to eq(default_language)
-        expect(controller.session).to include_language_information_for(default_language)
-      end
-    end
-
-    context "with language in the session" do
-      before do
-        allow(controller).to receive(:session).and_return(alchemy_language_id: klingon.id)
-        allow(Alchemy::Language).to receive(:current).and_return(klingon)
-      end
-
-      it "should use the language from the session" do
-        controller.send :set_alchemy_language
-        expect(assigns(:language)).to eq(klingon)
-        expect(Alchemy::Language.current).to eq(klingon)
-      end
-    end
-
-    context "with lang param" do
-      it "should set the language" do
-        allow(controller).to receive(:params).and_return(locale: klingon.code)
-        controller.send :set_alchemy_language
-        expect(assigns(:language)).to eq(klingon)
-        expect(Alchemy::Language.current).to eq(klingon)
-        expect(controller.session).to include_language_information_for(klingon)
-      end
-
-      context "for language that does not exist" do
-        before do
-          allow(controller).to receive(:params).and_return(locale: 'fo')
-          controller.send :set_alchemy_language
-        end
-
-        it "should set the language to default" do
-          expect(assigns(:language)).to eq(default_language)
-          expect(Alchemy::Language.current).to eq(default_language)
-          expect(controller.session).to include_language_information_for(default_language)
-        end
-      end
-    end
-  end
-end

data/spec/libraries/i18n_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe ".t" do
-    it 'scopes translations intro alchemy namespace' do
-      expect(::I18n).to receive(:t).with(:foo, default: 'Foo', scope: ['alchemy'])
-      ::Alchemy.t(:foo)
-    end
-  end
-
-  describe I18n do
-    describe '.translation_files' do
-      subject { I18n.translation_files }
-      it      { is_expected.to be_a Array }
-      it      { is_expected.to be_any { |f| f =~ /alchemy.*.yml/ } }
-    end
-
-    describe '.available_locales' do
-      subject { I18n.available_locales }
-      before  { allow(I18n).to receive(:translation_files).and_return(['alchemy.kl.yml']) }
-      it      { is_expected.to be_a Array }
-      it      { is_expected.to include :kl }
-
-      context 'when locales are already set in @@available_locales' do
-        before { I18n.class_variable_set(:@@available_locales, [:kl, :jp]) }
-        it     { is_expected.to eq([:kl, :jp]) }
-      end
-    end
-
-    describe '.available_locales=' do
-      it "assigns the given locales to @@available_locales" do
-        I18n.available_locales = [:kl, :nl, :cn]
-        expect(I18n.class_variable_get(:@@available_locales)).to eq([:kl, :nl, :cn])
-      end
-    end
-  end
-end

data/spec/libraries/kaminari/scoped_pagination_url_helper_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe Kaminari::Helpers::Tag do
-  subject { Kaminari::Helpers::Tag.new(template, options) }
-
-  let(:template) { double(params: {}) }
-  let(:scope)    { double(url_for: '') }
-
-  describe '#page_url_for' do
-    context "with scope option given" do
-      let(:options) { {scope: scope} }
-
-      it "calls url_for on that url proxy scope." do
-        expect(template).not_to receive(:url_for)
-        expect(scope).to receive(:url_for)
-        subject.page_url_for(1)
-      end
-    end
-
-    context "with no scope option given" do
-      let(:options) { {} }
-
-      it "calls url_for on the template." do
-        expect(template).to receive(:url_for)
-        expect(scope).not_to receive(:url_for)
-        subject.page_url_for(1)
-      end
-    end
-  end
-end

data/spec/libraries/modules_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  class ModulesTestController < ApplicationController
-    include Modules
-  end
-
-  describe Modules do
-    let(:controller)      { ModulesTestController.new }
-    let(:alchemy_modules) { YAML.load_file(File.expand_path('../../../config/alchemy/modules.yml', __FILE__)) }
-
-    describe '#module_definition_for' do
-      subject { controller.module_definition_for(name) }
-
-      let(:dashboard_module) { alchemy_modules.first }
-
-      context 'with a string given as name' do
-        let(:name) { 'dashboard' }
-
-        it "returns the module definition" do
-          is_expected.to eq(dashboard_module)
-        end
-      end
-
-      context 'with a hash given as name' do
-        let(:controller_name) { 'alchemy/admin/dashboard' }
-        let(:name)            { {controller: controller_name, action: 'index'} }
-
-        it "returns the module definition" do
-          is_expected.to eq(dashboard_module)
-        end
-
-        context 'with leading slash in controller name' do
-          let(:controller_name) { '/alchemy/admin/dashboard' }
-
-          it "returns the module definition" do
-            is_expected.to eq(dashboard_module)
-          end
-        end
-      end
-
-      context 'with nil given as name' do
-        let(:name) { nil }
-        it 'raises an error' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-    end
-
-    describe '.register_module' do
-      let(:alchemy_module) do
-        {
-          'name' => 'module',
-          'navigation' => {
-            'controller' => 'admin/controller_name',
-            'action' => 'index'
-          }
-        }
-      end
-
-      it "registers a module definition into global list of modules" do
-        Modules.register_module(alchemy_module)
-        expect(Modules.alchemy_modules).to include(alchemy_module)
-      end
-    end
-  end
-end