active_element 0.0.1 → 0.0.2

data/lib/active_element/permissions_check.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Verifies provided permissions against required permissions.
+  class PermissionsCheck
+    def initialize(required:, actual:, controller_path:, action_name:, rails_component:)
+      @required = required.presence || []
+      @actual = normalized(actual)
+      @controller_name = controller_path.to_s.gsub('/', '_')
+      @action_name = action_name.to_s
+      @rails_component = rails_component
+      raise_unprotected_route_error if applicable.empty?
+    end
+
+    def permitted?
+      rails_component.environment == 'development' || missing.blank?
+    end
+
+    def message
+      return development_environment_message if rails_component.environment == 'development'
+      return "User access granted for permission(s): #{applicable.join(', ')}" if permitted?
+
+      "User access forbidden. Missing user permission(s): #{missing.join(', ')}"
+    end
+
+    def missing
+      @missing ||= applicable.reject do |permission|
+        actual.include?(permission.to_s)
+      end.map(&:to_s)
+    end
+
+    def applicable
+      @applicable ||= default_permissions + required_permissions
+    end
+
+    private
+
+    attr_reader :required, :actual, :controller_name, :action_name, :rails_component
+
+    def development_environment_message
+      "Bypassed permission(s) in development environment: #{applicable.join(', ')}"
+    end
+
+    def default_permissions
+      return [] if normalized_action.nil?
+
+      ["can_#{normalized_action}_#{rails_component.application_name}_#{controller_name}"]
+    end
+
+    def required_permissions
+      @required_permissions ||= required.map do |permission, options|
+        next nil unless applicable?(options)
+
+        permission
+      end.compact
+    end
+
+    def normalized_action
+      {
+        index: 'list',
+        show: 'view',
+        edit: 'edit',
+        update: 'edit',
+        create: 'create',
+        new: 'create',
+        destroy: 'delete'
+      }.fetch(action_name.to_sym, nil)
+    end
+
+    def normalized(val)
+      return val&.map(&:to_s) if val.is_a?(Array)
+
+      [val].map(&:to_s)
+    end
+
+    def applicable?(options)
+      return true if !options.key?(:only) && !options.key?(:except)
+      return true if only_applicable?(options)
+      return false if except_applicable?(options)
+
+      false
+    end
+
+    def only_applicable?(options)
+      return false unless options.key?(:only)
+
+      normalized(options.fetch(:only)).include?(action_name)
+    end
+
+    def except_applicable?(options)
+      return false unless options.key?(:except)
+
+      normalized(options.fetch(:except)).include?(action_name)
+    end
+
+    def raise_unprotected_route_error
+      raise UnprotectedRouteError,
+            "#{controller_name.titleize.tr(' ', '')}##{action_name} must be protected with `permit_user`"
+    end
+  end
+end

data/lib/active_element/rails_component.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Abstraction of various Rails interfaces.
+  class RailsComponent
+    def initialize(rails)
+      @rails = rails
+    end
+
+    def routes
+      rails.application.routes
+    end
+
+    def environment
+      rails.env
+    end
+
+    def application_name
+      rails.application.class.module_parent.name.underscore
+    end
+
+    # Provides array of e.g. { path: "/admin/users", controller: "admin/users", action: "index" }
+    def route_paths_with_requirements
+      rails.application.routes.routes.map do |route|
+        { path: path_from_route_spec(route.path.spec) }.merge(route.requirements)
+      end
+    end
+
+    private
+
+    attr_reader :rails
+
+    # Translates "/admin/users/:id(.:format)" into "/admin/users"
+    def path_from_route_spec(spec)
+      # FIXME: Find a more robust way of doing this ?
+      path = spec.to_s.gsub(/:.*/, '').gsub(/\(.*/, '')
+      path == '/' ? path : path.chomp
+    end
+  end
+end

data/lib/active_element/route.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Abstraction of a Rails route, includes path, permitted state (based on user permissions), etc.
+  class Route
+    include Comparable
+
+    attr_reader :controller
+
+    def initialize(controller:, required_permissions:, user_permissions:, action:, rails_component:)
+      @controller = controller
+      @required_permissions = required_permissions
+      @user_permissions = user_permissions
+      @action = action
+      @rails_component = rails_component
+    end
+
+    def <=>(other)
+      return 0 if path.nil? && other.path.nil?
+      return 1 if path.nil?
+      return -1 if other.path.nil?
+
+      path <=> other.path
+    end
+
+    def permitted?
+      return @permitted if defined?(@permitted)
+
+      (@permitted = permitted_action?)
+    end
+
+    def path
+      @path ||= rails_path
+    end
+
+    def primary?
+      return false if rails_non_index_action?
+      return false unless resourceless_get_request?
+
+      true
+    end
+
+    def title
+      controller.controller_name.titleize
+    end
+
+    def spec
+      { controller: controller.controller_path, action: action.to_s }
+    end
+
+    def permissions
+      permissions_check.applicable.map(&:to_s)
+    end
+
+    def rails_route?
+      rails_application_route? || active_element_route?
+    end
+
+    private
+
+    attr_reader :required_permissions, :user_permissions, :action, :rails_component
+
+    def rails_application_route?
+      rails_component.routes.routes.map(&:requirements).any? { |requirements| match_spec?(requirements) }
+    end
+
+    def active_element_route?
+      ActiveElement::Engine.routes.routes.map(&:requirements).any? { |requirements| match_spec?(requirements) }
+    end
+
+    def match_spec?(requirements)
+      requirements.to_set.superset?(spec.to_set)
+    end
+
+    def rails_path
+      rails_component.routes.url_for(**spec, only_path: true)
+    rescue ActionController::UrlGenerationError
+      nil
+    end
+
+    def rails_non_index_action?
+      %i[show edit update new create destroy].include?(action)
+    end
+
+    def resourceless_get_request?
+      spec_set = spec.to_set
+      rails_component.routes.routes.find do |rails_route|
+        next false unless rails_route.requirements&.to_set&.superset?(spec_set)
+        next false unless rails_route.verb == 'GET'
+        next false unless rails_route.required_parts.empty?
+
+        true
+      end
+    end
+
+    def permitted_action?
+      permissions_check.permitted?
+    rescue UnprotectedRouteError
+      false
+    end
+
+    def permissions_check
+      @permissions_check ||= PermissionsCheck.new(
+        required: required_permissions,
+        actual: user_permissions,
+        controller_path: controller.controller_path,
+        action_name: action,
+        rails_component: rails_component
+      )
+    end
+  end
+end

data/lib/active_element/routes.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveElement
+  # Provides an interface to available admin routes, used for populating a default navigation bar
+  # and detecting available permitted routes if the default root path is not permitted.
+  class Routes
+    include Enumerable
+
+    def initialize(rails_component:, permissions: [])
+      @permissions = permissions
+      @rails_component = rails_component
+    end
+
+    def permitted
+      @permitted ||= available_routes.select(&:permitted?)
+    end
+
+    def available
+      @available ||= available_routes
+    end
+
+    def alternative_routes
+      @alternative_routes ||= available.select(&:primary?).reject { |route| route.path == '/' }
+    end
+
+    def each(&block)
+      available.each(&block)
+    end
+
+    private
+
+    attr_reader :permissions, :rails_component
+
+    def available_routes
+      @available_routes ||= descendants_with_permissions.map do |descendant, required_permissions|
+        descendant.public_methods(false).map do |action|
+          route(descendant, action, required_permissions)
+        end
+      end.flatten.compact.select(&:rails_route?).sort
+    end
+
+    def descendants_with_permissions
+      @descendants_with_permissions ||= descendants.map do |controller_class|
+        [controller_class.new, controller_class.active_element_permissions]
+      end.compact
+    end
+
+    def descendants
+      @descendants ||= ActiveElement::ApplicationController.descendants
+    end
+
+    def route(controller, action, required_permissions)
+      Route.new(
+        controller: controller,
+        action: action,
+        required_permissions: required_permissions,
+        user_permissions: permissions,
+        rails_component: rails_component
+      )
+    end
+  end
+end

data/lib/active_element/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveElement
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/active_element.rb

@@ -1,8 +1,98 @@
 # frozen_string_literal: true
 
+require 'faraday'
+require 'rouge'
+require 'kaminari'
+require 'sassc'
+require 'bootstrap'
+require 'active_record'
+# require 'rspec/documentation' # FIXME: Load dynamically when running rspec documentation command.
+
 require_relative 'active_element/version'
+require_relative 'active_element/active_record_text_search_authorization'
+require_relative 'active_element/colorized_string'
+require_relative 'active_element/active_menu_link'
+require_relative 'active_element/permissions_check'
+require_relative 'active_element/controller_action'
+require_relative 'active_element/rails_component'
+require_relative 'active_element/route'
+require_relative 'active_element/routes'
+require_relative 'active_element/component'
+require_relative 'active_element/components'
+require_relative 'active_element/engine'
 
+# ActiveElement API Admin UI template and menu system.
 module ActiveElement
   class Error < StandardError; end
-  # Your code goes here...
+  class UnprotectedRouteError < Error; end
+  class UnknownAttributeError < Error; end
+
+  class << self
+    attr_writer :application_name, :navbar_items
+
+    def application_title
+      @application_name || RailsComponent.new(Rails).application_name.titleize
+    end
+
+    def navbar_items(user)
+      @navbar_items || inferred_navbar_items(user)
+    end
+
+    def active_path_class(user:, current_navbar_item:, current_path:, controller_path:, action_name:)
+      if ActiveMenuLink.new(
+        rails_component: RailsComponent.new(Rails),
+        navbar_items: navbar_items(user),
+        current_path: current_path,
+        current_navbar_item: current_navbar_item,
+        controller_path: controller_path,
+        action_name: action_name
+      ).active?
+        'active'
+      end
+    end
+
+    def json_pretty_print(json)
+      Components::Util.json_pretty_print(json)
+    end
+
+    def with_silenced_logging(&block)
+      return block.call unless silence_logging?
+
+      ActiveSupport::Notifications.unsubscribe 'render_template.action_view'
+      ActiveSupport::Notifications.unsubscribe 'render_partial.action_view'
+
+      block.call
+    end
+
+    def silence_logging?
+      return true unless Rails.env.development? || Rails.env.test?
+      return true unless ENV.key?('ACTIVE_ELEMENT_DEBUG')
+
+      false
+    end
+
+    def eager_load_controllers
+      Pathname.new(__dir__)
+              .join('../app/controllers/active_element')
+              .glob('**/*_controller.rb')
+              .each { |path| require path }
+      Rails.root.join('app/controllers/admin/').glob('**/*_controller.rb').each { |path| require path }
+    end
+
+    private
+
+    def inferred_navbar_items(user)
+      eager_load_controllers
+      user_routes(user).available.select(&:primary?).map do |route|
+        { path: route.path, title: route.title, spec: route.spec }
+      end
+    end
+
+    def user_routes(user)
+      ActiveElement::Routes.new(
+        permissions: user.permissions,
+        rails_component: ActiveElement::RailsComponent.new(Rails)
+      )
+    end
+  end
 end

data/lib/tasks/active_element.rake

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+namespace :active_element do
+  desc 'Displays all permissions used by this application'
+  task permissions: :environment do
+    ActiveElement.eager_load_controllers
+    routes = ActiveElement::Routes.new(rails_component: ActiveElement::RailsComponent.new(Rails))
+    permissions = routes.map(&:permissions).flatten.sort.uniq
+    $stdout.puts ActiveElement::ColorizedString.new(
+      "\nThe following user permissions are used by this application:\n",
+      color: :light_blue
+    ).value
+    permissions.each do |permission|
+      color = { list: :cyan, view: :blue, create: :green, delete: :red, edit: :yellow }.find do |action, _|
+        permission.include?("_#{action}_")
+      end&.last || :purple
+      $stdout.puts('    ' \
+                   "#{ActiveElement::ColorizedString.new('*', color: :white).value} " \
+                   "#{ActiveElement::ColorizedString.new(permission, color: color).value}")
+    end
+    $stdout.puts
+  end
+end

data/rspec-documentation/dummy

@@ -0,0 +1 @@
+../spec/dummy/

data/rspec-documentation/pages/Components/Forms.md

@@ -0,0 +1 @@
+# Forms

data/rspec-documentation/pages/Components/Tables.md

@@ -0,0 +1,47 @@
+# Tables
+
+## Collection Table
+
+The _Collection Table_ component provides a vertical table containing a collection of items item. Use with _Active Record_ model instances, an array of objects that extend `ActiveModel::Naming`, or simple hash-like objects.
+
+Field types are automatically inferred from their respective database columns and rendered using an appropriate formatter.
+
+```rspec:html
+class User < ActiveRecord::Base
+end
+
+collection = [
+  User.new(name: 'John', email: 'john@example.com'),
+  User.new(name: 'Jane', email: 'jane@example.org')
+]
+
+html = active_element_component.table collection: collection, fields: [:name, :email]
+
+it_documents html do
+  expect(html).to include 'John'
+end
+```
+
+## Item Table
+
+The _Item Table_ component provides a horizontal table containing a single item and its attributes. It supports the same item types as [Collection Tables](##Collection Table).
+
+```rspec:html
+class User < ActiveRecord::Base
+end
+
+item = User.new(name: 'John', email: 'john@example.com', overview: 'Writes Ruby code for a living.')
+
+html = active_element_component.table item: item, fields: [:name, :email, :password, :secret]
+
+it_documents html do
+  expect(html).to include 'John'
+end
+```
+
+```rspec
+foo = { foo: 'bar', baz: 'qux' }
+it_documents foo do
+  expect('hello').to eql 'hello'
+end
+```

data/rspec-documentation/pages/Components/Tabs.md

@@ -0,0 +1 @@
+# Tabs

data/rspec-documentation/pages/Components.md

@@ -0,0 +1 @@
+# Components

data/rspec-documentation/pages/Decorators/Inline Decorators.md

@@ -0,0 +1 @@
+# Inline Decorators

data/rspec-documentation/pages/Decorators/View Decorators.md

@@ -0,0 +1 @@
+# View Decorators

data/rspec-documentation/pages/Index.md

@@ -0,0 +1,3 @@
+# ActiveElement
+
+_ActiveElement_ provides a number of components for use in _Ruby on Rails_ views as well as a flexible auhorization model.

data/rspec-documentation/pages/Util/I18n.md

@@ -0,0 +1 @@
+# Internationalization

data/rspec-documentation/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'active_element'
+require_relative 'dummy/config/environment'
+
+RSpec::Documentation.configure do |config|
+  ActiveRecord::Migration.class_eval do
+    drop_table :users
+  rescue ActiveRecord::StatementInvalid
+    # Skip
+  end
+
+  ActiveRecord::Migration.class_eval do
+    create_table :users do |t|
+      t.string :name
+      t.string :email
+      t.text :overview
+    end
+  end
+
+  config.context do |context|
+    class StubbedController < ActiveElement::ApplicationController
+
+      def initialize(*args, &block)
+        append_view_path File.expand_path(File.join(__dir__, '../app/views/'))
+
+        super
+      end
+
+      def params
+        {}
+      end
+    end
+
+    context.active_element_component = ActiveElement::Component.new(StubbedController.new)
+  end
+end