gearhead 0.1.0

data/lib/gearhead/actions/index.rb

@@ -0,0 +1,88 @@
+module Gearhead
+  module Actions
+    class Index
+      delegate_missing_to :@request
+
+      def self.build(gear, request)
+        new(gear, request).build
+      end
+
+      attr_reader :scope, :gear, :request
+      def initialize(gear, request)
+        @gear = gear
+        @request = request
+        @collection = find_collection
+        @serializer_options = {}
+      end
+
+      def build
+        @collection = apply_includes
+        @collection = apply_scope
+        @collection = apply_query
+        @collection = apply_pagination
+        @collection = apply_serializer
+        @collection
+      end
+
+      private
+
+      def find_collection
+        @gear.resource.all
+      end
+
+      def apply_includes
+        return @collection if @gear._gear_includes.nil?
+        @collection.includes(@gear._gear_includes)
+      end
+
+      def apply_scope
+        return @collection unless valid_scope?(scope)
+        if query = @gear._gear_defined_scopes[scope.to_sym].presence
+          query.call(@collection)
+        else
+          @collection.send(scope)
+        end
+      end
+
+      def scope
+        params[:scope].presence || @gear._gear_default_scope
+      end
+
+      def valid_scope?(scope)
+        return false if scope.nil?
+        @gear._gear_defined_scopes.key?(scope.to_sym)
+      end
+
+      def apply_query
+        return @collection unless params[:q].present?
+
+        @collection.ransack(params[:q]).result
+      end
+
+      def apply_pagination
+        return @collection unless @gear.paginate?
+
+        paginator = ::Gearhead::Paginators::Paginator.paginate(@collection, self).call
+        @collection = paginator.collection
+        @serialization_options = paginator.serialization_options
+
+        @collection
+      end
+
+      def apply_serializer
+        @gear.serializer_class.new(@collection, serialization_options)
+      end
+
+      def serialization_options
+        {
+            links: {
+                first: @serialization_options[:first_url],
+                last: @serialization_options[:last_url],
+                prev: @serialization_options[:prev_url],
+                next: @serialization_options[:next_url]
+            }
+        }
+      end
+    end
+  end
+end

data/lib/gearhead/actions/show.rb

@@ -0,0 +1,22 @@
+module Gearhead
+  module Actions
+    class Show
+      delegate_missing_to :@request
+
+      def self.build(gear, request, resource:)
+        new(gear, request, resource: resource).build
+      end
+
+      attr_reader :resource, :gear, :request
+      def initialize(gear, request, resource:)
+        @gear = gear
+        @request = request
+        @resource = resource
+      end
+
+      def build
+        @resource
+      end
+    end
+  end
+end

data/lib/gearhead/actions/update.rb

@@ -0,0 +1,25 @@
+module Gearhead
+  module Actions
+    class Update
+      delegate_missing_to :@request
+
+      def self.build(gear, request, resource:)
+        new(gear, request, resource: resource).build
+      end
+
+      attr_reader :resource, :gear, :request
+      def initialize(gear, request, resource:)
+        @gear = gear
+        @request = request
+        @resource = resource
+      end
+
+      # todo
+      def build
+        params = ActionController::Parameters.new(@request.params).require(:post).permit(:person_id, :private)
+        @resource.assign_attributes(params)
+        @resource
+      end
+    end
+  end
+end

data/lib/gearhead/configuration.rb

@@ -0,0 +1,68 @@
+module Gearhead
+  # not implemented
+  class RansackConfiguration
+    attr_accessor :enabled, :predicates, :associations, :attributes, :scopes
+    def initialize
+      @enabled = true
+      @predicates = true
+      @associations = true
+      @attributes = true
+      @scopes = true
+    end
+
+    def enabled?
+      @enabled
+    end
+  end
+
+  class SerializationConfiguration
+    attr_accessor :adapter
+    def initialize
+      @adapter = :fast_jsonapi
+    end
+  end
+
+  class PaginationConfiguration
+    attr_accessor :adapter, :include_total, :per_page
+    def initialize
+      @adapter = :pagy
+      @enabled = true
+      @per_page = 30
+    end
+
+    def enabled?
+      @enabled
+    end
+  end
+
+  class AutomountConfiguration
+    attr_accessor :enabled, :excludes, :includes
+
+    def initialize
+      @enabled = false
+      @excludes = []
+      @includes = []
+    end
+
+    def enabled?
+      @enabled
+    end
+  end
+
+  class Configuration
+    attr_accessor :actions, :current_user, :endpoint, :serializer, :scope, :ignored_params,
+                  :automount, :pagination, :serialization, :base_controller
+
+    def initialize
+      @actions = [:index, :create, :show, :update, :destroy]
+      @current_user = nil
+      @scope = nil
+      @endpoint = "/gearhead"
+      @ignored_params = [:id, :created_at, :updated_at]
+      @automount = AutomountConfiguration.new
+      @pagination = PaginationConfiguration.new
+      @serialization = SerializationConfiguration.new
+      @base_controller = 'ApplicationController'
+    end
+  end
+end

data/lib/gearhead/engine.rb

@@ -0,0 +1,10 @@
+module Gearhead
+  class Engine < Rails::Engine
+    config.to_prepare do
+      Dir.glob(Rails.root.join("app/gears/**/*.rb")).each do |gear|
+        load gear
+      end
+      Rails.autoloaders.main.ignore(Rails.root.join('app/gears'))
+    end
+  end
+end

data/lib/gearhead/extensions/actions.rb

@@ -0,0 +1,29 @@
+module Gearhead
+  module Extensions
+    module Actions
+      def self.included(klass)
+        klass.define_gear_setting :enabled_actions, Gearhead.config.actions.map(&:to_sym)
+      end
+
+      def disable_actions(*actions)
+        @_gear_enabled_actions -= actions.map(&:to_sym)
+      end
+
+      def actions(*args)
+        options = args.extract_options!
+        @_gear_enabled_actions = if options[:except]
+                                   @_gear_enabled_actions - options[:except].map(&:to_sym)
+                                 elsif options[:only]
+                                   options[:only].map(&:to_sym)
+                                 else
+                                   args.map(&:to_sym)
+                                 end
+      end
+
+      def action_enabled?(action)
+        @_gear_enabled_actions.include?(action)
+      end
+
+    end
+  end
+end

data/lib/gearhead/extensions/associations.rb

@@ -0,0 +1,13 @@
+module Gearhead
+  module Extensions
+    module Associations
+      def self.included(klass)
+        klass.define_gear_setting :associations, { belongs_to: [], has_many: [], has_one: [] }
+      end
+
+      def belongs_to(klass)
+        @_gear_associations[:belongs_to] << klass
+      end
+    end
+  end
+end

data/lib/gearhead/extensions/attributes.rb

@@ -0,0 +1,20 @@
+module Gearhead
+  module Extensions
+    module Attributes
+      def self.included(klass)
+      end
+
+      def _gear_attributes
+        @_gear_attributes
+      end
+
+      def attributes(*attrs)
+        @_gear_attributes = *attrs
+      end
+
+      def default_attributes
+        @resource.columns_hash.keys.map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/gearhead/extensions/custom_actions.rb

@@ -0,0 +1,36 @@
+module Gearhead
+  module Extensions
+    module CustomActions
+      def self.included(klass)
+        klass.define_gear_setting :collection_actions, {}
+        klass.define_gear_setting :member_actions, {}
+      end
+
+      class CustomAction
+        attr_reader :name, :verbs, :block
+        def initialize(name, verbs, &block)
+          @name = name
+          @verbs = verbs
+          @block = block
+        end
+      end
+
+      def custom_action(type, name, options = {}, &block)
+        vias = (Array(options[:via]).presence || [:get]).map { |via| via.downcase.to_sym }
+        if type == :member
+          @_gear_member_actions[name] = CustomAction.new(name, vias, &block)
+        else
+          @_gear_collection_actions[name] = CustomAction.new(name, vias, &block)
+        end
+      end
+
+      def member_action(name, options = {}, &block)
+        custom_action(:member, name, options, &block)
+      end
+
+      def collection_action(name, options = {}, &block)
+        custom_action(:collection, name, options, &block)
+      end
+    end
+  end
+end

data/lib/gearhead/extensions/enabled_actions.rb

@@ -0,0 +1,9 @@
+module Gearhead
+  module Extensions
+    module EnabledActions
+      def finder(&block)
+        @_gear_finder = block
+      end
+    end
+  end
+end

data/lib/gearhead/extensions/finder.rb

@@ -0,0 +1,14 @@
+module Gearhead
+  module Extensions
+    module Finder
+      def self.included(klass)
+        klass.define_gear_setting :finder, nil
+        klass.define_gear_setting :param_key, :id
+      end
+
+      def finder(&block)
+        @_gear_finder = block
+      end
+    end
+  end
+end

data/lib/gearhead/extensions/pagination.rb

@@ -0,0 +1,26 @@
+module Gearhead
+  module Extensions
+    module Pagination
+      def self.included(klass)
+        klass.define_gear_setting :paginate, Gearhead.config.pagination.enabled?
+        klass.define_gear_setting :per_page, Gearhead.config.pagination.per_page
+      end
+
+      def paginate?
+        @_gear_paginate === true
+      end
+
+      def paginate(val)
+        @_gear_paginate = val === true
+      end
+
+      def per_page(int)
+        @_gear_per_page = int
+      end
+
+      def pagination_total(boolean)
+        @_gear_pagination_total = boolean
+      end
+    end
+  end
+end

data/lib/gearhead/extensions/permitted_params.rb

@@ -0,0 +1,36 @@
+module Gearhead
+  module Extensions
+    module PermittedParams
+      def self.included(klass)
+        klass.define_gear_setting :permitted_params, {}
+        klass.define_gear_setting :action_params, {}
+      end
+
+      def permit_params(*args)
+        options = args.extract_options!
+        if options[:only]
+          keys = Array(args[:only]).map(&:to_sym)
+          keys.each do |key|
+            @_gear_action_params[key] = args
+          end
+        else
+          @_gear_permitted_params = args
+        end
+      end
+
+      def permitted_attributes(action)
+        if attrs = @_gear_action_params[action.to_sym].presence
+          attrs
+        elsif attrs = @_gear_permitted_params.presence
+          attrs
+        else
+          @resource.columns_hash.keys.map(&:to_sym)
+        end
+      end
+
+      def permitted_params(action)
+        permitted_attributes(action)
+      end
+    end
+  end
+end

data/lib/gearhead/extensions/querying.rb

@@ -0,0 +1,13 @@
+module Gearhead
+  module Extensions
+    module Querying
+      def self.included(klass)
+        klass.define_gear_setting :includes, {}
+      end
+
+      def includes(*keys)
+        @_gear_includes = *keys
+      end
+    end
+  end
+end

data/lib/gearhead/extensions/scoping.rb

@@ -0,0 +1,18 @@
+module Gearhead
+  module Extensions
+    module Scoping
+      def self.included(klass)
+        klass.define_gear_setting :default_scope, nil
+        klass.define_gear_setting :defined_scopes, {}
+      end
+
+      def register_scope(name, query = nil)
+        @_gear_defined_scopes[name] = query
+      end
+
+      def default_scope(scope = nil)
+        @_gear_default_scope = scope
+      end
+    end
+  end
+end