adminterface 0.2.0 → 0.3.0

data/app/javascript/adminterface/lib/__tests__/has_many.spec.js

@@ -0,0 +1,224 @@
+import fs from 'fs'
+import path from 'path'
+import Sortable from 'sortablejs'
+import HasManyClass from '../has_many'
+
+jest.mock('sortablejs')
+
+describe('HasMany', () => {
+  const html = fs.readFileSync(path.resolve(__dirname, './has_many.html'))
+  let element
+
+  const options = {
+    list: '.has-many-list',
+    item: 'fieldset.has_many_fields',
+    addLink: 'a.button.has_many_add',
+    removeLink: 'a.button.has_many_remove',
+    destroyInput: 'input[name$="[_destroy]"]'
+  }
+
+  beforeEach(() => {
+    document.documentElement.innerHTML = html
+    element = document.querySelector('div')
+    global.adminterface = {
+      addObserver: jest.fn()
+    }
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  test('constructor initiates correctly', () => {
+    const spyOnBind = jest.spyOn(HasManyClass.prototype, '_bind')
+    spyOnBind.mockImplementation(() => {})
+
+    const HasMany = new HasManyClass(element)
+    expect(HasMany.element).toStrictEqual(element)
+
+    expect(spyOnBind).toHaveBeenCalledTimes(1)
+  })
+
+  test('bind calls bindEvents, initSortable and admininterface', () => {
+    const spyOnBindEvents = jest.spyOn(HasManyClass.prototype, '_bindEvents')
+    spyOnBindEvents.mockImplementation(() => {})
+
+    const spyOnInitSortable = jest.spyOn(HasManyClass.prototype, '_initSortable')
+    spyOnInitSortable.mockImplementation(() => {})
+
+    const HasMany = new HasManyClass(element)
+
+    expect(spyOnBindEvents).toHaveBeenCalledWith(element)
+    expect(spyOnInitSortable).toHaveBeenCalledTimes(1)
+    expect(global.adminterface.addObserver).toHaveBeenCalledTimes(1)
+    expect(global.adminterface.addObserver).toHaveBeenCalledWith(
+      element,
+      HasMany,
+      HasMany.constructor.name,
+      []
+    )
+  })
+
+  test('initSortable assigns new instance of Sortable to sortable property', () => {
+    const spyOnBindEvents = jest.spyOn(HasManyClass.prototype, '_bindEvents')
+    spyOnBindEvents.mockImplementation(() => {})
+
+    const HasMany = new HasManyClass(element)
+
+    const MockSortableArgument = {
+      handle: '.handle',
+      animation: 150,
+      ghostClass: 'sortable-placeholder',
+      dragClass: 'sortable-drag',
+      onUpdate: expect.any(Function)
+    }
+
+    expect(Sortable).toHaveBeenCalledTimes(1)
+    expect(Sortable).toHaveBeenCalledWith(
+      document.querySelector(HasMany.options.list),
+      MockSortableArgument
+    )
+    const sortable = new Sortable(
+      document.querySelector(HasMany.options.list),
+      MockSortableArgument
+    )
+    expect(HasMany.sortable.toString()).toStrictEqual(sortable.toString())
+  })
+
+  test('recomputePosition changes sortableInput value', () => {
+    const query = 'input[name$="[address]"]'
+    const sortableInput = element.querySelector(query)
+
+    expect(sortableInput.value.length).not.toEqual(0)
+
+    const HasMany = new HasManyClass(element)
+    HasMany._recomputePosition()
+
+    expect(sortableInput.value.length).toEqual(0)
+  })
+
+  test('bindDestroyEvent called with element and change event added', () => {
+    const spyOnBindDestroyEvent = jest.spyOn(
+      HasManyClass.prototype,
+      '_bindDestroyEvent'
+    )
+    const destroyInput = document.querySelector(options.destroyInput)
+    destroyInput.addEventListener = jest.fn()
+
+    new HasManyClass(element) // eslint-disable-line no-new
+
+    expect(spyOnBindDestroyEvent).toHaveBeenCalledTimes(1)
+    expect(spyOnBindDestroyEvent).toHaveBeenCalledWith(destroyInput)
+
+    expect(destroyInput.addEventListener).toHaveBeenCalledTimes(1)
+    expect(destroyInput.addEventListener).toHaveBeenCalledWith(
+      'change',
+      expect.any(Function)
+    )
+  })
+
+  test('bindRemoveEvent called with element and click event added', () => {
+    const spyOnBindRemoveEvent = jest.spyOn(
+      HasManyClass.prototype,
+      '_bindRemoveEvent'
+    )
+    const removeLinks = document.querySelector(options.removeLink)
+    removeLinks.addEventListener = jest.fn()
+
+    new HasManyClass(element) // eslint-disable-line no-new
+
+    expect(spyOnBindRemoveEvent).toHaveBeenCalledTimes(1)
+    expect(spyOnBindRemoveEvent).toHaveBeenCalledWith(removeLinks)
+
+    expect(removeLinks.addEventListener).toHaveBeenCalledTimes(1)
+    expect(removeLinks.addEventListener).toHaveBeenCalledWith(
+      'click',
+      expect.any(Function)
+    )
+  })
+
+  test('bindRemoveEventCallBack', () => {
+    const mockEvent = {
+      preventDefault: () => {},
+      target: document.body.querySelector('fieldset')
+    }
+    const spyOnRecomputePosition = jest.spyOn(
+      HasManyClass.prototype,
+      '_recomputePosition'
+    )
+    const HasMany = new HasManyClass(element)
+    const spyOnDispatch = jest.spyOn(HasMany.element, 'dispatchEvent')
+
+    const fieldSet = mockEvent.target.closest(HasMany.options.item)
+    fieldSet.remove = jest.fn()
+
+    const parent = HasMany.element
+    const removeBeforeEvent = HasMany.events.removeBefore
+    removeBeforeEvent.detail = { fieldSet, parent }
+    const removeAfterEvent = HasMany.events.removeAfter
+    removeAfterEvent.detail = { fieldSet, parent }
+
+    const output = HasMany._bindRemoveEventCallBack(mockEvent)
+
+    expect(spyOnRecomputePosition).toHaveBeenCalledTimes(1)
+    expect(spyOnDispatch).toHaveBeenCalledTimes(2)
+    expect(spyOnDispatch.mock.calls).toMatchObject([
+      [removeBeforeEvent],
+      [removeAfterEvent]
+    ])
+    expect(fieldSet.remove).toHaveBeenCalledTimes(1)
+    expect(output).toBeTruthy()
+  })
+
+  test('bindAddEvent called with correctly element and click event added', () => {
+    const spyOnBindAddEvent = jest.spyOn(
+      HasManyClass.prototype,
+      '_bindAddEvent'
+    )
+
+    const addLinks = document.querySelector(options.addLink)
+    addLinks.addEventListener = jest.fn()
+
+    new HasManyClass(element) // eslint-disable-line no-new
+
+    expect(spyOnBindAddEvent).toHaveBeenCalledTimes(1)
+    expect(spyOnBindAddEvent).toHaveBeenCalledWith(addLinks)
+
+    expect(addLinks.addEventListener).toHaveBeenCalledTimes(1)
+    expect(addLinks.addEventListener).toHaveBeenCalledWith(
+      'click',
+      expect.any(Function)
+    )
+  })
+
+  test('bindAddEventCallBack', () => {
+    const mockEvent = {
+      preventDefault: () => {},
+      target: document.body.querySelector(options.addLink)
+    }
+    const HasMany = new HasManyClass(element)
+    const spyOnDispatchEvent = jest.spyOn(HasMany.element, 'dispatchEvent')
+    const $list = HasMany.element.querySelector(HasMany.options.list)
+    const spyOnListAppendChild = jest.spyOn($list, 'appendChild')
+    const spyOnBindEvents = jest.spyOn(HasMany, '_bindEvents')
+    const spyOnRecomputePosition = jest.spyOn(HasMany, '_recomputePosition')
+    const beforeAdd = HasMany.events.addBefore
+    const parent = HasMany.element
+    const datasetHTML = document.createElement('div')
+
+    const output = HasMany._bindAddEventCallBack(mockEvent)
+
+    expect(spyOnDispatchEvent).toHaveBeenCalledTimes(2)
+    expect(spyOnDispatchEvent.mock.calls).toMatchObject([
+      [beforeAdd, [parent]],
+      [HasMany.events.addAfter]
+    ])
+
+    expect(spyOnListAppendChild).toHaveBeenCalledTimes(1)
+    expect(spyOnListAppendChild).toHaveBeenCalledWith(datasetHTML)
+    expect(spyOnBindEvents).toHaveBeenCalledTimes(1)
+    expect(spyOnBindEvents).toHaveBeenCalledWith(datasetHTML)
+    expect(spyOnRecomputePosition).toHaveBeenCalledTimes(1)
+    expect(output).toBeTruthy()
+  })
+})

data/app/javascript/adminterface/lib/__tests__/header_toggler.html

@@ -0,0 +1,2 @@
+<div class="breakpoint-up-helper">
+</div>

data/app/javascript/adminterface/lib/__tests__/header_toggler.spec.js

@@ -0,0 +1,212 @@
+import fs from 'fs'
+import path from 'path'
+import HeaderTogglerClass from '../header_toggler'
+import * as utilModule from '../utils'
+
+describe('CheckboxToggler', () => {
+  const html = fs.readFileSync(path.resolve(__dirname, './header_toggler.html'))
+  const options = { item: 1 }
+  const defaults = {
+    container: 'body',
+    activeClass: 'header-active',
+    cookieName: 'header-state',
+    cookieExpireSec: 30 * 24 * 60 * 60
+  }
+  const mockEvent = {
+    preventDefault: jest.fn()
+  }
+
+  let element
+  let $container
+  let windowSpy
+  let spyOnAdd
+  let spyOnRemove
+  let spyOnCookieGet
+  let spyOnCookieSet
+
+  beforeEach(() => {
+    document.body.innerHTML = html
+    document.body.classList.remove(defaults.activeClass)
+    element = document.body.firstChild
+    $container = document.querySelector(defaults.container)
+
+    windowSpy = jest.spyOn(window, 'window', 'get')
+    spyOnCookieGet = jest.spyOn(utilModule, 'cookieGet')
+    spyOnCookieSet = jest.spyOn(utilModule, 'cookieSet')
+    spyOnCookieSet.mockImplementation(() => {})
+    spyOnAdd = jest.spyOn(HeaderTogglerClass.prototype, '_add')
+    spyOnRemove = jest.spyOn(HeaderTogglerClass.prototype, '_remove')
+
+    global.adminterface = {
+      addObserver: jest.fn()
+    }
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  test('constructor initiates correctly', () => {
+    const spyOnBind = jest.spyOn(HeaderTogglerClass.prototype, '_bind')
+    spyOnBind.mockImplementation(() => {})
+
+    const HeaderToggler = new HeaderTogglerClass(element, options)
+
+    expect(HeaderToggler.element).toStrictEqual(element)
+    expect(HeaderToggler.options).toStrictEqual({ ...defaults, ...options })
+
+    expect(spyOnBind).toHaveBeenCalledTimes(1)
+  })
+
+  test('bind calls cookieGet once with correct argument', () => {
+    const HeaderToggler = new HeaderTogglerClass(element, options)
+
+    expect(spyOnCookieGet).toHaveBeenCalledTimes(1)
+    expect(spyOnCookieGet).toHaveBeenCalledWith(HeaderToggler.options.cookieName)
+  })
+
+  test('bind calls add when cookie is activeClass and breakpointHelper is visible', () => {
+    windowSpy.mockImplementation(() => ({
+      getComputedStyle: () => ({
+        visibility: 'visible'
+      })
+    }))
+    spyOnCookieGet.mockImplementation(() => 'header-active')
+
+    new HeaderTogglerClass(element, options) // eslint-disable-line no-new
+
+    expect(spyOnAdd).toHaveBeenCalledTimes(1)
+  })
+
+  test('bind does not call add when cookie is not activeClass and breakpoint is visible', () => {
+    windowSpy.mockImplementation(() => ({
+      getComputedStyle: () => ({
+        visibility: 'visible'
+      })
+    }))
+    spyOnCookieGet.mockImplementation(() => 'header-not-active')
+
+    new HeaderTogglerClass(element, options) // eslint-disable-line no-new
+
+    expect(spyOnAdd).not.toHaveBeenCalled()
+  })
+
+  test('bind does not call add when cookie is activeClass and breakpointHelper is not visible', () => {
+    windowSpy.mockImplementation(() => ({
+      getComputedStyle: () => ({
+        visibility: 'not-visible'
+      })
+    }))
+    spyOnCookieGet.mockImplementation(() => 'header-active')
+
+    new HeaderTogglerClass(element, options) // eslint-disable-line no-new
+
+    expect(spyOnAdd).not.toHaveBeenCalled()
+  })
+
+  test('bind calls addEventListener on element once with click', () => {
+    const HeaderToggler = new HeaderTogglerClass(element, options)
+    const spyOnElementAddEventListener = jest.spyOn(HeaderToggler.element, 'addEventListener')
+
+    HeaderToggler._bind()
+
+    expect(spyOnElementAddEventListener).toHaveBeenCalledTimes(1)
+    expect(spyOnElementAddEventListener).toHaveBeenCalledWith(
+      'click',
+      expect.any(Function)
+    )
+  })
+
+  test('bind calls adminterface addObserver once with correct argument', () => {
+    const spyOnAddObserver = jest.spyOn(global.adminterface, 'addObserver')
+
+    const HeaderToggler = new HeaderTogglerClass(element, options)
+
+    expect(spyOnAddObserver).toHaveBeenCalledTimes(1)
+    expect(spyOnAddObserver).toHaveBeenCalledWith(
+      HeaderToggler.element,
+      HeaderToggler,
+      HeaderToggler.constructor.name
+    )
+  })
+
+  test('clickCallback calls preventDefault', () => {
+    spyOnAdd.mockImplementation(() => {})
+    spyOnRemove.mockImplementation(() => {})
+
+    const HeaderToggler = new HeaderTogglerClass(element, options)
+
+    HeaderToggler._clickCallback(mockEvent, $container, HeaderToggler)
+
+    expect(mockEvent.preventDefault).toHaveBeenCalledTimes(1)
+  })
+
+  test('clickCallback calls remove when $container class contains activeClass', () => {
+    spyOnAdd.mockImplementation(() => {})
+    spyOnRemove.mockImplementation(() => {})
+
+    const HeaderToggler = new HeaderTogglerClass(element, options)
+
+    document.body.classList.add(HeaderToggler.options.activeClass)
+
+    spyOnAdd.mockClear()
+    HeaderToggler._clickCallback(mockEvent, $container, HeaderToggler)
+
+    expect(spyOnRemove).toHaveBeenCalledTimes(1)
+    expect(spyOnAdd).not.toHaveBeenCalled()
+  })
+
+  test('clickCallback calls add when $container class does not contain activeClass', () => {
+    spyOnAdd.mockImplementation(() => {})
+    spyOnRemove.mockImplementation(() => {})
+
+    const HeaderToggler = new HeaderTogglerClass(element, options)
+
+    spyOnAdd.mockClear()
+    HeaderToggler._clickCallback(mockEvent, $container, HeaderToggler)
+
+    expect(spyOnRemove).not.toHaveBeenCalled()
+    expect(spyOnAdd).toHaveBeenCalledTimes(1)
+  })
+
+  test('add calls $container.classList.add and cookieSet', () => {
+    const spyOnContainerClassListAdd = jest.spyOn($container.classList, 'add')
+
+    const HeaderToggler = new HeaderTogglerClass(element, options)
+    spyOnContainerClassListAdd.mockClear()
+    spyOnCookieSet.mockClear()
+    HeaderToggler._add()
+
+    expect(spyOnContainerClassListAdd).toHaveBeenCalledTimes(1)
+    expect(spyOnContainerClassListAdd).toHaveBeenCalledWith(
+      HeaderToggler.options.activeClass
+    )
+
+    expect(spyOnCookieSet).toHaveBeenCalledTimes(1)
+    expect(spyOnCookieSet).toHaveBeenCalledWith(
+      HeaderToggler.options.cookieName,
+      HeaderToggler.options.activeClass,
+      HeaderToggler.options.cookieExpireSec
+    )
+  })
+
+  test('remove calls $container.classList.remove and cookieSet', () => {
+    const spyOnContainerClassListRemove = jest.spyOn($container.classList, 'remove')
+
+    const HeaderToggler = new HeaderTogglerClass(element, options)
+    spyOnCookieSet.mockClear()
+    HeaderToggler._remove()
+
+    expect(spyOnContainerClassListRemove).toHaveBeenCalledTimes(1)
+    expect(spyOnContainerClassListRemove).toHaveBeenCalledWith(
+      HeaderToggler.options.activeClass
+    )
+
+    expect(spyOnCookieSet).toHaveBeenCalledTimes(1)
+    expect(spyOnCookieSet).toHaveBeenCalledWith(
+      HeaderToggler.options.cookieName,
+      null,
+      0
+    )
+  })
+})

data/app/javascript/adminterface/lib/__tests__/per_page.spec.js

@@ -0,0 +1,75 @@
+import PerPage from '../per_page'
+import * as utilModule from '../utils'
+
+describe('CheckboxToggler', () => {
+  const mockEvent = {
+    preventDefault: jest.fn()
+  }
+  const mockQueryString = '?email=someone@example.com'
+  const value = 1
+
+  let spyOnQueryStringToParams
+  let spyOnTurbolinks
+  let spyOnTurbolinksVisit
+  let spyOnToQueryString
+  let params
+
+  beforeEach(() => {
+    Object.defineProperty(window, 'location', {
+      value: {
+        search: mockQueryString
+      },
+      writable: true
+    })
+
+    params = utilModule.queryStringToParams().filter(({ name }) => name !== 'per_page' && name !== 'page')
+    params.push({ name: 'per_page', value })
+
+    spyOnQueryStringToParams = jest.spyOn(utilModule, 'queryStringToParams')
+    spyOnTurbolinks = jest.spyOn(utilModule, 'hasTurbolinks')
+    spyOnTurbolinksVisit = jest.spyOn(utilModule, 'turbolinksVisit')
+    spyOnToQueryString = jest.spyOn(utilModule, 'toQueryString')
+
+    PerPage.value = value
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+    mockEvent.preventDefault.mockClear()
+  })
+
+  test('update triggers queryStringToParams', () => {
+    PerPage._update(mockEvent)
+
+    expect(spyOnQueryStringToParams).toHaveBeenCalledTimes(1)
+  })
+
+  test('hasTurbolinks: true, update triggers preventDefault and turbolinksVisit', () => {
+    spyOnTurbolinks.mockImplementation(() => true)
+    spyOnTurbolinksVisit.mockImplementation(() => {})
+
+    PerPage._update(mockEvent)
+
+    expect(mockEvent.preventDefault).toHaveBeenCalledTimes(1)
+
+    expect(spyOnTurbolinksVisit).toHaveBeenCalledTimes(1)
+    expect(spyOnTurbolinksVisit).toHaveBeenCalledWith(params)
+
+    expect(spyOnToQueryString).not.toHaveBeenCalled()
+  })
+
+  test('hasTurbolinks: false, sets window.location.search to toQueryString output', () => {
+    spyOnTurbolinks.mockImplementation(() => false)
+    spyOnToQueryString.mockImplementation(params => params)
+
+    PerPage._update(mockEvent)
+
+    expect(mockEvent.preventDefault).not.toHaveBeenCalled()
+    expect(spyOnTurbolinksVisit).not.toHaveBeenCalled()
+
+    expect(spyOnToQueryString).toHaveBeenCalledTimes(1)
+    expect(spyOnToQueryString).toHaveBeenCalledWith(params)
+
+    expect(window.location.search).toStrictEqual(params)
+  })
+})

data/app/javascript/adminterface/lib/__tests__/utils.spec.js

@@ -1,4 +1,3 @@
-/* eslint-env jest */
 import {
   hasTurbolinks,
   turbolinksVisit,

data/app/javascript/adminterface/lib/has_many.js

@@ -51,54 +51,57 @@ class HasMany {
   }
 
   _bindAddEvent (el) {
-    el.addEventListener('click', (e) => {
-      let beforeAdd
-      const el = e.target
-      const parent = this.element
+    el.addEventListener('click', (e) => this._bindAddEventCallBack(e))
+  }
 
-      e.preventDefault()
-      parent.dispatchEvent(beforeAdd = this.events.addBefore, [parent])
+  _bindAddEventCallBack (e) {
+    let beforeAdd
+    const el = e.target
+    const parent = this.element
+    e.preventDefault()
+    parent.dispatchEvent(beforeAdd = this.events.addBefore, [parent])
 
-      if (!beforeAdd.defaultPrevented) {
-        let index = parent.dataset.hasManyIndex || parent.querySelectorAll(this.options.item).length - 1
-        parent.setAttribute('data-has-many-index', ++index)
+    if (!beforeAdd.defaultPrevented) {
+      let index = parent.dataset.hasManyIndex || parent.querySelectorAll(this.options.item).length - 1
+      parent.setAttribute('data-has-many-index', ++index)
 
-        const regex = new RegExp(el.dataset.placeholder, 'g')
-        const html = el.dataset.html.replaceAll(regex, index)
-        const newNode = document.createElement('div')
-        newNode.innerHTML = html
+      const regex = new RegExp(el.dataset.placeholder, 'g')
+      const html = el.dataset.html.replace(regex, index)
+      const newNode = document.createElement('div')
+      newNode.innerHTML = html
 
-        const fieldset = newNode.firstElementChild
-        const $list = this.element.querySelector(this.options.list)
+      const fieldset = newNode.firstElementChild
+      const $list = this.element.querySelector(this.options.list)
 
-        $list.appendChild(fieldset)
-        this._bindEvents(fieldset)
-        this._recomputePosition()
+      $list.appendChild(fieldset)
+      this._bindEvents(fieldset)
+      this._recomputePosition()
 
-        const addAfterEvent = this.events.addAfter
-        addAfterEvent.detail = { fieldset, parent }
-        return parent.dispatchEvent(this.events.addAfter)
-      }
-    })
+      const addAfterEvent = this.events.addAfter
+      addAfterEvent.detail = { fieldset, parent }
+      return parent.dispatchEvent(this.events.addAfter)
+    }
   }
 
   _bindRemoveEvent (el) {
-    el.addEventListener('click', (e) => {
-      const el = e.target
-      const parent = this.element
-      const fieldset = el.closest(this.options.item)
-      const removeBeforeEvent = this.events.removeBefore
-      const removeAfterEvent = this.events.removeAfter
-
-      e.preventDefault()
-      this._recomputePosition()
+    el.addEventListener('click', (e) => this._bindRemoveEventCallBack(e))
+  }
 
-      removeBeforeEvent.detail = { fieldset, parent }
-      removeAfterEvent.detail = { fieldset, parent }
-      parent.dispatchEvent(removeBeforeEvent)
-      fieldset.remove()
-      return parent.dispatchEvent(removeAfterEvent)
-    })
+  _bindRemoveEventCallBack (e) {
+    const el = e.target
+    const parent = this.element
+    const fieldset = el.closest(this.options.item)
+    const removeBeforeEvent = this.events.removeBefore
+    const removeAfterEvent = this.events.removeAfter
+
+    e.preventDefault()
+    this._recomputePosition()
+
+    removeBeforeEvent.detail = { fieldset, parent }
+    removeAfterEvent.detail = { fieldset, parent }
+    parent.dispatchEvent(removeBeforeEvent)
+    fieldset.remove()
+    return parent.dispatchEvent(removeAfterEvent)
   }
 
   _bindEvents (el) {

data/app/javascript/adminterface/lib/header_toggler.js

@@ -38,17 +38,19 @@ class HeaderToggler {
       this._add()
     }
 
-    this.element.addEventListener('click', function (e) {
-      e.preventDefault()
-      if ($container.classList.contains(_self.options.activeClass)) {
-        _self._remove()
-      } else {
-        _self._add()
-      }
-    })
+    this.element.addEventListener('click', (e) => this._clickCallback(e, $container, _self))
 
     adminterface.addObserver(this.element, this, this.constructor.name)
   }
+
+  _clickCallback (e, $container, _self) {
+    e.preventDefault()
+    if ($container.classList.contains(_self.options.activeClass)) {
+      _self._remove()
+    } else {
+      _self._add()
+    }
+  }
 }
 
 export default HeaderToggler

data/app/views/layouts/active_admin_logged_out.html.erb

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="<%=I18n.locale%>">
+<html lang="<%=I18n.locale%>" dir="<%= ActiveAdmin.application.lang_dir(self) %>">
   <head>
     <meta http-equiv="Content-type" content="text/html; charset=utf-8">
     <title><%= [@page_title, ActiveAdmin.application.site_title(self)].compact.join(" | ") %></title>

data/lib/adminterface/configs.rb

@@ -10,7 +10,11 @@ module Adminterface
     }.call.freeze
 
     module Configurable
-      attr_writer :components, :css_classes, :comments_pager, :comments_per_page, :pager, :comments_input
+      attr_writer :lang_dir, :components, :css_classes, :comments_pager, :comments_per_page, :pager, :comments_input
+
+      def lang_dir(...)
+        @lang_dir || namespace.lang_dir(...)
+      end
 
       def components
         namespace.components.deep_merge(@components || {})

data/lib/adminterface/engine.rb

@@ -11,12 +11,5 @@ module Adminterface
     include ::Adminterface::Initializers::ViewHelpers
     include ::Adminterface::Initializers::Views
     include ::Adminterface::Initializers::Comments
-
-    config.after_initialize do
-      unless defined?(::Rails::Generators) || defined?(::Rails::Console) ||
-          File.basename($0).eql?("rake")
-        ::Adminterface::License.verify!
-      end
-    end
   end
 end