tb_core 1.4.3.1 → 1.4.4

data/lib/spud_core/engine.rb

@@ -1,76 +0,0 @@
-require 'responders'
-require 'jquery-rails'
-require 'authlogic'
-require 'bootstrap-sass'
-require 'autoprefixer-rails'
-require 'will_paginate'
-require 'will_paginate-bootstrap'
-require 'breadcrumbs_on_rails'
-require 'rails-ujs'
-
-# this should eventually replace the Spud::Core namespace
-module TbCore
-end
-
-module Spud
-  module Core
-    class Engine < ::Rails::Engine
-      require "#{root}/lib/spud_core/errors"
-      require "#{root}/lib/spud_core/searchable"
-      require "#{root}/lib/tb_core/form_builder"
-      require "#{root}/lib/tb_core/table_header"
-
-      engine_name :tb_core
-      config.autoload_paths << "#{root}/lib"
-
-      initializer 'tb_core.controller_overrides' do |config|
-         ActionController::Base.class_eval do
-          include TbCore::BelongsToApp
-         end
-      end
-
-      initializer 'tb_core.model_overrides' do |config|
-        ActiveRecord::Base.class_eval do
-          include Spud::Searchable
-        end
-      end
-
-      initializer 'tb_core.admin', after: :admin do |config|
-        # Translate Hash configured permissions into SpudPermission objects
-        Spud::Core.permissions.collect! do |p|
-          if p.class == Hash
-            p = SpudPermission.new(p[:tag], p[:name], p[:apps])
-          end
-          p
-        end
-        # Append Users admin module
-        Spud::Core.config.admin_applications.unshift(name: 'Users',
-                                                     thumbnail: 'admin/users_thumb.png',
-                                                     url: '/admin/users',
-                                                     order: 100)
-        # Create default permissions for modules
-        Spud::Core.admin_applications.each do |admin_application|
-          admin_application[:key] ||= admin_application[:name].gsub(' ', '_').downcase.to_sym
-          tag = "admin.#{admin_application[:key]}.full_access"
-          name = "#{admin_application[:name]} admin"
-          apps = [admin_application[:key]]
-          Spud::Core.permissions.push(SpudPermission.new(tag, name, apps))
-        end
-      end
-
-      initializer 'tb_core.catch_all_route' do |config|
-        # Handle 404 errors if Spud::Cms is not installed
-        if !defined?(Spud::Cms)
-          config.routes_reloader.paths << File.expand_path('../catch_all_route.rb', __FILE__)
-        end
-      end
-
-      initializer 'tb_core.assets' do
-        Rails.application.config.assets.precompile += ['admin/users_thumb.png', 'admin/module_icon.png']
-      end
-
-    end
-  end
-end
-
-TbCore::Engine = Spud::Core::Engine

data/lib/spud_core/errors.rb

@@ -1,47 +0,0 @@
-class Spud::RequestError < StandardError
-  attr_accessor :request_url, :item, :template
-  attr_reader :code, :title
-
-  # For compatability reasons, this method accepts multiple styles of inputs
-  # Going forward the expected input will be:
-  #
-  # * item: The item that could not be found. String. (default = page)
-  # * template (named): ERB template you wish to render
-  #
-  def initialize(item_or_opts='page', opts={})
-    if item_or_opts.is_a?(Hash)
-      @item = item_or_opts[:item]
-      @template = item_or_opts[:template]
-    else
-      @item = item_or_opts
-      @template = opts[:template]
-    end
-    @template ||= 'layouts/error_page'
-    @title = I18n.t(:title, scope: [:tb_core, :errors, @i18n])
-    super(I18n.t(:message, scope: [:tb_core, :errors, @i18n], item: @item))
-  end
-end
-
-class Spud::AccessDeniedError < Spud::RequestError
-  def initialize(item_or_opts='page', opts={})
-    @code = 403
-    @i18n = 'access_denied'
-    super(item_or_opts, opts)
-  end
-end
-
-class Spud::NotFoundError < Spud::RequestError
-  def initialize(item_or_opts='page', opts={})
-    @code = 404
-    @i18n = 'not_found'
-    super(item_or_opts, opts)
-  end
-end
-
-class Spud::UnauthorizedError < Spud::RequestError
-  def initialize(item_or_opts='page', opts={})
-    @code = 401
-    @i18n = 'unauthorized'
-    super(item_or_opts, opts)
-  end
-end

data/lib/spud_core/version.rb

@@ -1,5 +0,0 @@
-module Spud
-  module Core
-    VERSION = '1.4.3.1'.freeze
-  end
-end

data/lib/tb_core/table_header.rb

@@ -1,92 +0,0 @@
-module TbCore
-  class TableHeader
-    attr_reader :context
-    attr_accessor :header_html
-
-    # Forward view helper methods to the view context
-    delegate :concat, :content_tag, :link_to, to: :context
-
-    def initialize(path_helper:, model: nil, params: {}, context:)
-      @path_helper = path_helper
-      @model = model
-      @params = params
-      @context = context
-    end
-
-    def capture(block)
-      @html = context.capture do
-        block.call(self)
-      end
-    end
-
-    def sortable(attribute, label: nil)
-      content_tag :th, class: classes_for_attribute(attribute) do
-        concat(link_to_for_attribute(attribute, label))
-        concat(sort_arrow_for_attribute(attribute))
-      end
-    end
-
-    def header(attribute, label: nil)
-      label ||= translated_attribute(attribute)
-      content_tag :th, label
-    end
-
-    def to_row
-      content_tag(:tr, @html)
-    end
-
-    def to_html
-      content_tag :thead, to_row, class: 'tb-table-header'
-    end
-
-    private
-
-    def translated_attribute(attribute)
-      if @model
-        @model.human_attribute_name(attribute)
-      else
-        context.t(attribute)
-      end
-    end
-
-    def current_direction
-      @params[:dir] || 'asc'
-    end
-
-    def inverted_direction
-      current_direction == 'asc' ? 'desc' : 'asc'
-    end
-
-    def determine_direction(attribute)
-      if @params[:sort].nil? || @params[:sort] != attribute.to_s
-        'asc'
-      else
-        inverted_direction
-      end
-    end
-
-    def classes_for_attribute(attribute)
-      classes = ['sortable']
-      if @params[:sort] == attribute.to_s
-        classes << 'sortable-active'
-        classes << "sortable-#{current_direction}"
-      end
-      classes.join(' ')
-    end
-
-    def link_to_for_attribute(attribute, label)
-      label ||= translated_attribute(attribute)
-      path = context.send(
-        @path_helper,
-        @params.merge(sort: attribute, dir: determine_direction(attribute))
-      )
-      link_to(label, path)
-    end
-
-    def sort_arrow_for_attribute(attribute)
-      return '' unless @params[:sort] == attribute.to_s
-      arrow_class = current_direction == 'asc' ? 'up' : 'down'
-      content_tag(:span, '', class: "glyphicon glyphicon-arrow-#{arrow_class}")
-    end
-  end
-end

data/spec/controllers/tb_core/sortable_params_spec.rb

@@ -1,64 +0,0 @@
-require 'rails_helper'
-
-describe TbCore::SortableParams, type: :controller do
-  controller do
-    include TbCore::SortableParams
-    sortable_by :first_name, :last_name, :email,
-                display_name: [:first_name, :last_name],
-                birth_date: 'user_birthdays.date :dir',
-                special: proc { |dir| "some_other_tables.whatever #{dir}" },
-                default: :last_name
-
-    def index; end
-  end
-
-  describe '#sort_direction' do
-    it 'returns asc' do
-      expect(controller.sort_direction).to eq(:asc)
-    end
-    it 'returns desc' do
-      controller.params[:dir] = 'desc'
-      expect(controller.sort_direction).to eq(:desc)
-    end
-  end
-
-  describe '#sort_attribute' do
-    it 'returns the default' do
-      expect(controller.sort_attribute).to eq(:last_name)
-    end
-    it 'returns the param' do
-      controller.params[:sort] = 'email'
-      expect(controller.sort_attribute).to eq(:email)
-    end
-  end
-
-  describe '#sortable_query' do
-    it 'returns the value as a hash' do
-      controller.params[:sort] = 'email'
-      expect(controller.sortable_query).to eq(email: :asc)
-    end
-
-    it 'returns a multi value hash' do
-      controller.params[:sort] = 'display_name'
-      controller.params[:dir] = 'desc'
-      expect(controller.sortable_query).to eq(first_name: :desc, last_name: :desc)
-    end
-
-    it 'returns a string with substitution' do
-      controller.params[:sort] = 'birth_date'
-      controller.params[:dir] = 'desc'
-      expect(controller.sortable_query).to eq('user_birthdays.date desc')
-    end
-
-    it 'returns a string by calling a proc' do
-      controller.params[:sort] = 'special'
-      controller.params[:dir] = 'desc'
-      expect(controller.sortable_query).to eq('some_other_tables.whatever desc')
-    end
-
-    it 'returns nothing' do
-      controller.params[:sort] = 'not_allowed'
-      expect(controller.sortable_query).to eq(nil)
-    end
-  end
-end