super 0.0.0 → 0.0.1

data/lib/super/controls.rb

@@ -0,0 +1,25 @@
+module Super
+  class Controls
+    def initialize(dashboard)
+      @dashboard = dashboard
+    end
+
+    attr_reader :dashboard
+
+    def method_missing(method_name, *args)
+      if @dashboard.respond_to?(method_name)
+        @dashboard.public_send(method_name, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, _ = false)
+      if @dashboard.respond_to?(method_name)
+        true
+      else
+        super
+      end
+    end
+  end
+end

data/lib/super/display.rb

@@ -0,0 +1,9 @@
+module Super
+  class Display
+    def self.format(schema, resource, column)
+      value = resource.public_send(column)
+
+      schema.fields[column].present(value)
+    end
+  end
+end

data/lib/super/display/schema_types.rb

@@ -0,0 +1,41 @@
+module Super
+  class Display
+    # This schema type is meant to be used for +#index+ or +#show+ actions to
+    # transform database fields into something that is human friendly.
+    #
+    # Note: The constants under "Defined Under Namespace" are considered
+    # private.
+    #
+    #   class MemberDashboard
+    #     # ...
+    #
+    #     def show_schema
+    #       Super::Schema.new(Super::Display::SchemaTypes.new) do |fields, type|
+    #         fields[:name] = type.dynamic { |name| name }
+    #         fields[:rank] = type.dynamic { |rank| rank }
+    #         fields[:position] = type.dynamic { |position| position }
+    #         fields[:ship] = type.dynamic { |ship| "#{ship.name} (Ship ##{ship.id})" }
+    #         fields[:created_at] = type.dynamic { |created_at| created_at.iso8601 }
+    #         fields[:updated_at] = type.dynamic { |updated_at| updated_at.iso8601 }
+    #       end
+    #     end
+    #
+    #     # ...
+    #   end
+    class SchemaTypes
+      class Dynamic
+        def initialize(transform_block)
+          @transform_block = transform_block
+        end
+
+        def present(field)
+          @transform_block.call(field)
+        end
+      end
+
+      def dynamic(&transform_block)
+        Dynamic.new(transform_block)
+      end
+    end
+  end
+end

data/lib/super/engine.rb

@@ -1,4 +1,9 @@
 module Super
   class Engine < ::Rails::Engine
+    initializer "super.assets.precompile" do |app|
+      if Super::Assets.sprockets_available?
+        app.config.assets.precompile << "config/super_manifest.js"
+      end
+    end
   end
 end

data/lib/super/error.rb

@@ -0,0 +1,8 @@
+module Super
+  class Error < StandardError
+    class UnconfiguredConfiguration < Error; end
+    class InvalidConfiguration < Error; end
+    class InvalidStyle < Error; end
+    class InvalidPluginArgument < Error; end
+  end
+end

data/lib/super/form/schema_types.rb

@@ -0,0 +1,47 @@
+module Super
+  class Form
+    # This schema type is used on your +#edit+ and +#new+ forms
+    #
+    # Note: The constants under "Defined Under Namespace" are considered
+    # private.
+    #
+    #   class MemberDashboard
+    #     # ...
+    #
+    #     def new_schema
+    #       Super::Schema.new(Super::Form::SchemaTypes.new) do |fields, type|
+    #         fields[:name] = type.generic("write_type_text")
+    #         fields[:rank] = type.generic("write_type_select", collection: Member.ranks.keys)
+    #         fields[:position] = type.generic("write_type_text")
+    #         fields[:ship_id] = type.generic(
+    #           "write_type_select",
+    #           collection: Ship.all.map { |s| ["#{s.name} (Ship ##{s.id})", s.id] },
+    #         )
+    #       end
+    #     end
+    #
+    #     # ...
+    #   end
+    class SchemaTypes
+      class Generic
+        def initialize(partial_path:, extras:)
+          @partial_path = partial_path
+          @extras = extras
+        end
+
+        def to_partial_path
+          @partial_path
+        end
+
+        def [](key)
+          @extras[key]
+        end
+      end
+
+      def generic(partial_path, extras = nil)
+        extras ||= {}
+        Generic.new(partial_path: partial_path, extras: extras)
+      end
+    end
+  end
+end

data/lib/super/inline_callback.rb

@@ -0,0 +1,82 @@
+module Super
+  module InlineCallback
+    extend ActiveSupport::Concern
+
+    included do
+      register_inline_callback(:yield, on: :index)
+    end
+
+    class_methods do
+      def inline_callback_registry
+        @inline_callback_registry ||= {}
+      end
+
+      def inline_callback_defined?(action)
+        action = action.to_sym
+
+        inline_callback_registry.key?(action)
+      end
+
+      def inline_callbacks_for(action, check_ancestors = true)
+        action = action.to_sym
+
+        inline_callback_registry[action] ||= {}
+
+        if check_ancestors
+          ancestors.each do |ancestor|
+            if ancestor.respond_to?(:inline_callback_defined?)
+              if ancestor.inline_callback_defined?(action)
+                parent_class_callbacks = ancestor.inline_callbacks_for(action, false)
+                inline_callback_registry[action] = parent_class_callbacks.merge(inline_callback_registry[action])
+              end
+            end
+
+            if ancestor == Super::ApplicationController
+              break
+            end
+          end
+        end
+
+        inline_callback_registry[action]
+      end
+
+      def register_inline_callback(callback, on:, after: nil)
+        action = on.to_sym
+        after = after.to_sym if after.respond_to?(:to_sym)
+
+        callbacks = inline_callbacks_for(action)
+        if !callbacks.key?(callback)
+          callbacks[callback] = []
+        end
+
+        if after
+          callbacks[callback].push(after)
+        end
+      end
+    end
+
+    def with_inline_callbacks
+      action = params[:action].to_sym
+
+      callbacks = self.class.inline_callbacks_for(action)
+
+      each_node = -> (&b) { callbacks.each_key(&b) }
+      each_child = -> (cb, &b) { callbacks[cb].each(&b) }
+
+      yield_called = false
+
+      TSort.tsort_each(each_node, each_child) do |callback|
+        if callback == :yield
+          yield_called = true
+          yield
+        else
+          send(callback)
+        end
+      end
+
+      if !yield_called
+        yield
+      end
+    end
+  end
+end

data/lib/super/navigation/automatic.rb

@@ -0,0 +1,69 @@
+module Super
+  class Navigation
+    class Automatic
+      def initialize(route_namespace:)
+        route_namespace = route_namespace.to_s
+
+        if route_namespace.include?("/")
+          raise "Can't be nested namespace"
+        end
+
+        @route_namespace = route_namespace
+      end
+
+      def each
+        if !block_given?
+          return enum_for(:each)
+        end
+
+        navigable_namespace_routes = Rails.application.routes.routes.select do |route|
+          path_spec = route.path.spec
+
+          next if route.verb != "GET"
+          next if !path_spec.respond_to?(:right)
+          next if path_spec.right.left.to_s != @route_namespace
+          next if route.required_parts.any?
+          next if route.defaults.empty?
+
+          true
+        end
+
+        navigable_defaults = navigable_namespace_routes.map do |route|
+          controller_name = route.defaults[:controller] + "_controller"
+          _controller =
+            begin
+              controller_name.camelize.constantize
+            rescue NameError
+              warn("[super] Couldn't find controller: #{controller_name}")
+              next
+            end
+
+          route.defaults
+        end
+
+        grouped_navigable_defaults =
+          navigable_defaults.compact.uniq.group_by { |d| d[:controller] }
+
+        grouped_navigable_defaults.each do |controller, defaults|
+          actions = defaults.map { |d| [d[:action], d[:action]] }.to_h
+          action = actions["index"] || actions["show"]
+
+          next if action.nil?
+
+          path =
+            begin
+              Rails.application.routes.url_for(
+                controller: controller,
+                action: action,
+                only_path: true
+              )
+            rescue ActionController::UrlGenerationError
+              next
+            end
+
+          yield(controller.split("/").last.humanize, path)
+        end
+      end
+    end
+  end
+end

data/lib/super/pagination.rb

@@ -0,0 +1,59 @@
+module Super
+  class Pagination
+    include Enumerable
+
+    attr_reader :current_pageno
+    attr_reader :limit
+
+    def initialize(total_count:, limit:, query_params:, page_query_param:)
+      @total_count = total_count.to_i
+      @limit = limit.to_i
+      @query_params = query_params
+      @page_query_param = page_query_param
+
+      self.current_pageno = query_params[page_query_param]
+    end
+
+    def offset
+      limit * (current_pageno - 1)
+    end
+
+    def current_pageno=(pageno)
+      pageno = pageno.to_i
+
+      @current_pageno =
+        if pageno.zero?
+          1
+        else
+          pageno
+        end
+    end
+
+    def each
+      if !block_given?
+        return enum_for(:each)
+      end
+
+      quotient, remainder = @total_count.divmod(@limit)
+      pages =
+        if remainder.zero?
+          quotient
+        else
+          quotient + 1
+        end
+
+      (1..pages).each do |pageno|
+        is_current_page = pageno == current_pageno
+        display = pageno.to_s
+        page_query_params = @query_params.dup
+        if pageno == 1
+          page_query_params.delete(:page)
+        else
+          page_query_params[@page_query_param] = pageno
+        end
+
+        yield(page_query_params, is_current_page, display)
+      end
+    end
+  end
+end

data/lib/super/plugin.rb

@@ -0,0 +1,89 @@
+module Super
+  class Pluggable < Module
+    def initialize(registry_name)
+      @registry_name = registry_name
+    end
+
+    def included(base)
+      super
+
+      PluginRegistry.base_set(@registry_name, base)
+
+      plugins = PluginRegistry.plugins_for(@registry_name)
+
+      plugins.each do |klass, method_name|
+        base.public_send(method_name, klass)
+      end
+    end
+  end
+
+  class PluginRegistry
+    class << self
+      def include_to(name, klass)
+        plugin_push(name.to_sym, :include, klass)
+      end
+
+      def prepend_to(name, klass)
+        plugin_push(name.to_sym, :prepend, klass)
+      end
+
+      def plugins_for(name)
+        name = name.to_sym
+
+        plugins.fetch(name) { {} }
+      end
+
+      def base_set(name, klass)
+        name = name.to_sym
+
+        if !klass.kind_of?(Class)
+          raise Error::InvalidPluginArgument,
+            "Received `#{klass}` which must be a class"
+        end
+
+        bases[name] = klass
+
+        true
+      end
+
+      def base_get(name)
+        name = name.to_sym
+
+        bases[name]
+      end
+
+      private
+
+      def plugin_push(name, method_name, klass)
+        if ![:include, :prepend].include?(method_name)
+          raise Error::InvalidPluginArgument,
+            "Received `#{method_name.inspect}`, must be either :include or :prepend"
+        end
+
+        if !klass.kind_of?(Module)
+          raise Error::InvalidPluginArgument,
+            "Received `#{klass}` which must be a module"
+        end
+
+        plugins[name] ||= {}
+        plugins[name][klass] = method_name
+
+        base = base_get(name)
+
+        if base
+          base.public_send(method_name, klass)
+        end
+
+        true
+      end
+
+      def plugins
+        @plugins ||= {}
+      end
+
+      def bases
+        @bases ||= {}
+      end
+    end
+  end
+end