gearhead 0.1.0

data/lib/gearhead/extensions/serialization.rb

@@ -0,0 +1,21 @@
+module Gearhead
+  module Extensions
+    module Serialization
+      def self.included(klass)
+      end
+
+      def serializer(klass)
+        @_gear_serializer = klass
+      end
+
+      def serializer_class
+        real_serializer = Serializers::Lookup.for(:resource)
+        if real_serializer.respond_to?(:for)
+          real_serializer.for(self)
+        else
+          real_serializer
+        end
+      end
+    end
+  end
+end

data/lib/gearhead/gear.rb

@@ -0,0 +1,56 @@
+module Gearhead
+  module Settings
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.class_attribute :settings, default: {}
+    end
+
+    def define_gear_setting(name, default = nil)
+      instance_variable_set("@_gear_#{name}", default)
+      ivar = "@_gear_#{name}"
+      self.class.define_method :"_gear_#{name}" do
+        return instance_variable_get(ivar) if instance_variable_defined?(ivar)
+        instance_variable_get("@_gear_#{name}")
+      end
+      self.class.define_method :"_gear_#{name}=" do |value|
+        instance_variable_set("@_gear_#{name}", value)
+      end
+    end
+
+    module ClassMethods
+      def define_gear_setting(name, default = nil)
+        settings[name] = default
+      end
+    end
+  end
+  class Gear
+    include Settings
+
+    include Extensions::Actions
+    include Extensions::Attributes
+    include Extensions::Associations
+    include Extensions::CustomActions
+    include Extensions::Finder
+    include Extensions::Pagination
+    include Extensions::PermittedParams
+    include Extensions::Querying
+    include Extensions::Scoping
+    include Extensions::Serialization
+
+    attr_reader :resource
+
+    def initialize(resource_class, options = {})
+      @resource_class = resource_class
+      @resource = @resource_class.to_s.constantize
+      @options = options
+
+      self.class.settings.each do |k,v|
+        define_gear_setting k, v
+      end
+    end
+
+    def path
+      @options[:path] || @resource.model_name.route_key
+    end
+  end
+end

data/lib/gearhead/gear_lookup.rb

@@ -0,0 +1,35 @@
+module Gearhead
+  class GearLookup
+    def self.for(request)
+      new(request).gear
+    end
+
+    attr_reader :request
+    def initialize(request)
+      @request = request
+    end
+
+    # if the resource is already mounted, we don't want to expose it twice. return false
+    # return nil if we don't know the class
+    def gear
+      registered_gear = Gearhead.registry.find(request.params[:resource_class])
+      return registered_gear if registered_gear
+      return nil if inferred_resource_class.nil?
+      return false if Gearhead.registry.for_resource(inferred_resource_class.name)
+
+      default_gear
+    end
+
+    private
+
+    def default_gear
+      return nil unless Gearhead.config.automount.enabled?
+
+      Gear.new(inferred_resource_class)
+    end
+
+    def inferred_resource_class
+      request.params[:resource_class].classify.safe_constantize
+    end
+  end
+end

data/lib/gearhead/gearbox.rb

@@ -0,0 +1,83 @@
+module Gearhead
+  class Gearbox
+    def initialize
+    end
+
+    def setup!
+      # nothing
+    end
+
+    def prepare!
+      ActiveSupport::Dependencies.autoload_paths -= load_paths
+      Rails.application.config.eager_load_paths -= load_paths
+      attach_reloader
+    end
+
+    # Event that gets triggered on load of Active Admin
+    BeforeLoadEvent = "gearbox.application.before_load".freeze
+    AfterLoadEvent = "gearbox.application.after_load".freeze
+
+    def load!
+      unless loaded?
+        ActiveSupport::Notifications.publish BeforeLoadEvent, self # before_load hook
+        files.each { |file| load file } # load files
+        ActiveSupport::Notifications.publish AfterLoadEvent, self # after_load hook
+        @@loaded = true
+      end
+    end
+
+    def files
+      load_paths.flatten.compact.uniq.flat_map { |path| Dir["#{path}/**/*.rb"] }.sort
+    end
+
+    def load_paths
+      [File.expand_path("app/gears", Rails.root)]
+    end
+
+    def loaded?
+      @@loaded ||= false
+    end
+
+    def unload!
+      @@loaded = false
+    end
+
+    def routes(rails_router)
+      load!
+      Router.new(router: rails_router).apply
+    end
+
+    private
+
+    def attach_reloader
+      Rails.application.config.after_initialize do |app|
+        unload_gearhead = -> { Gearhead.gearbox.unload! }
+
+        if app.config.reload_classes_only_on_change
+           ActiveSupport::Reloader.to_prepare(prepend: true, &unload_gearhead)
+        else
+          ActiveSupport::Reloader.to_complete(&unload_gearhead)
+        end
+
+        admin_dirs = {}
+
+        load_paths.each do |path|
+          admin_dirs[path] = [:rb]
+        end
+
+        routes_reloader = app.config.file_watcher.new([], admin_dirs) do
+          app.reload_routes!
+        end
+
+        app.reloaders << routes_reloader
+
+        ActiveSupport::Reloader.to_prepare do
+           unless Gearhead.gearbox.loaded?
+            routes_reloader.execute_if_updated
+            Gearhead.application.load!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gearhead/paginators/lookup.rb

@@ -0,0 +1,27 @@
+module Gearhead
+  module Paginators
+    class Lookup
+      def self.for(action)
+        new(action).paginator
+      end
+
+      def initialize(action)
+        @action = action.to_s
+      end
+
+      def paginator
+        "::Gearhead::Paginators::#{adapter}Paginator".constantize
+      end
+
+      private
+
+      def adapter_name
+        ::Gearhead.config.pagination.adapter
+      end
+
+      def adapter
+        adapter_name.to_s.classify
+      end
+    end
+  end
+end

data/lib/gearhead/paginators/paginator.rb

@@ -0,0 +1,48 @@
+module Gearhead
+  module Paginators
+    class Paginator
+      def self.paginate(records, action)
+        ::Gearhead::Paginators::Lookup.for(action).new(records, action)
+      end
+
+      attr_reader :collection
+      def initialize(records, action)
+        @records = records
+        @collection = nil
+        @action = action
+      end
+
+      # should set @collection
+      def paginate
+        raise NotImplementedError, "define paginate and set @collection"
+      end
+
+      def call
+        paginate
+        self
+      end
+
+      def serialization_options
+        {}
+      end
+
+      private
+
+      def per_page
+        gear._gear_per_page
+      end
+
+      def page
+        request.params[:page] || 1
+      end
+
+      def gear
+        @action.gear
+      end
+
+      def request
+        @action.request
+      end
+    end
+  end
+end

data/lib/gearhead/paginators/pagy_paginator.rb

@@ -0,0 +1,17 @@
+require 'pagy/extras/metadata'
+
+module Gearhead
+  module Paginators
+    class PagyPaginator < Paginator
+      include Pagy::Backend
+
+      def paginate
+        @pagy, @collection = pagy(@records, items: per_page, page: page)
+      end
+
+      def serialization_options
+        pagy_metadata(@pagy)
+      end
+    end
+  end
+end

data/lib/gearhead/paginators/will_paginate_paginator.rb

@@ -0,0 +1,13 @@
+module Gearhead
+  module Paginators
+    class WillPaginatePaginator < Paginator
+      def paginate
+        @collection = @records.paginate(page: page, per_page: per_page)
+      end
+
+      def serialization_options
+        abort
+      end
+    end
+  end
+end

data/lib/gearhead/params_builder.rb

@@ -0,0 +1,14 @@
+module Gearhead
+  class ParamsBuilder
+    def initialize(page)
+      @page = page
+    end
+
+    def for(action)
+      params = @page.gear.permitted_params(action).map.with_object({}) do |key, obj|
+        obj[key] = @page.request.params[key]
+      end
+      params
+    end
+  end
+end

data/lib/gearhead/registry.rb

@@ -0,0 +1,26 @@
+module Gearhead
+  class Registry
+    def initialize
+      @resource_map = {}
+      @router = {}
+    end
+
+    def register(gear)
+      @resource_map[gear.resource.name] = gear
+      @router[gear.path] = gear
+      true
+    end
+
+    def for_resource(resource)
+      @resource_map[resource]
+    end
+
+    def find(path)
+      @router[path]
+    end
+
+    def all
+      @resource_map.values
+    end
+  end
+end

data/lib/gearhead/resource_finder.rb

@@ -0,0 +1,20 @@
+module Gearhead
+  class ResourceFinder
+    def self.for(gear, params)
+      new(gear, params).resource
+    end
+
+    def initialize(gear, params)
+      @gear = gear
+      @params = params
+    end
+
+    def resource
+      if @gear._gear_finder.present?
+        @gear._gear_finder.call(@params)
+      else
+        @gear.resource.find_by(@gear._gear_param_key => @params[:resource_id])
+      end
+    end
+  end
+end

data/lib/gearhead/router.rb

@@ -0,0 +1,51 @@
+module Gearhead
+  class Router
+    attr_reader :router
+
+    def initialize(router:)
+      @router = router
+    end
+
+    def apply
+      define_gear_routes
+    end
+
+    def define_gear_routes
+      ::Gearhead.registry.all.each do |thing|
+        @router.resources thing.resource.model_name.route_key, path: [::Gearhead.config.endpoint, thing.path].join("/"), controller: "gearhead/gears", param: :resource_id, defaults: { resource_class: thing.resource.model_name.route_key } do
+          define_actions(thing)
+        end
+      end
+    end
+
+    def define_actions(gear)
+      @router.member do
+        gear._gear_member_actions.values.each do |custom_action|
+          custom_action.verbs.each do |verb|
+            args = [custom_action.name, to: 'gearhead/gears#member_action', defaults: { member_action: custom_action.name }]
+            router.send(verb, *args)
+          end
+        end
+      end
+
+      @router.collection do
+        gear._gear_collection_actions.values.each do |custom_action|
+
+          custom_action.verbs.each do |verb|
+
+            args = [custom_action.name, to: 'gearhead/gears#collection_action', defaults: { collection_action: custom_action.name }]
+            router.send(verb, *args)
+          end
+        end
+      end
+    end
+
+    def build_action(action)
+      build_route(action.verbs, action.name)
+    end
+
+    def build_route(verbs, *args)
+      Array.wrap(verbs).each { |verb| router.send(verb, *args) }
+    end
+  end
+end

data/lib/gearhead/serializers/active_model_serializers/invalid_request_serializer.rb

@@ -0,0 +1,7 @@
+module Gearhead
+  module Serializers
+    module ActiveModelSerializers
+      class InvalidRequestSerializer < ::Gearhead::Serializers::InvalidRequestSerializer; end
+    end
+  end
+end

data/lib/gearhead/serializers/active_model_serializers/invalid_resource_serializer.rb

@@ -0,0 +1,7 @@
+module Gearhead
+  module Serializers
+    module ActiveModelSerializers
+      class InvalidResourceSerializer < ::Gearhead::Serializers::InvalidResourceSerializer; end
+    end
+  end
+end

data/lib/gearhead/serializers/active_model_serializers/resource_serializer.rb

@@ -0,0 +1,16 @@
+module Gearhead
+  module Serializers
+    module ActiveModelSerializers
+      class ResourceSerializer
+        def self.for(page)
+          if defined?(ActiveModelSerializers::Serializer)
+            klass = Class.new(ActiveModelSerializers::Serializer)
+            klass.attributes *(page._gear_attributes.presence || page.default_attributes)
+
+            klass
+          end
+        end
+      end
+    end
+  end
+end