instant-api 0.1.1

data/lib/instant_api/controller/build_destroy.rb

@@ -0,0 +1,23 @@
+module InstantApi::Controller
+  class BuildDestroy
+
+    def initialize(controller, model_class_name = nil)
+      @controller = controller
+    end
+
+    def build
+      @controller.class_eval(&build_destroy)
+    end
+
+    private
+
+    def build_destroy
+      Proc.new do
+        def destroy
+          resource.destroy!
+          render status: 200, nothing: true
+        end
+      end
+    end
+  end
+end

data/lib/instant_api/controller/build_edit.rb

@@ -0,0 +1,11 @@
+require 'instant_api/controller/build_show'
+
+module InstantApi::Controller
+  class BuildEdit < BuildShow
+
+    def initialize(controller, model_class_name = nil)
+      @controller = controller
+      @method = 'edit'
+    end
+  end
+end

data/lib/instant_api/controller/build_index.rb

@@ -0,0 +1,39 @@
+module InstantApi::Controller
+  class BuildIndex
+
+    attr_reader :model_class_name, :controller
+
+    def initialize(controller, model_class_name)
+      @controller = controller
+      @model_class_name = model_class_name
+    end
+
+    def build
+      controller.class_eval(&build_index)
+    end
+
+    private
+    def build_index
+      body = %Q{
+        require 'instant_api/model/collection'
+        require 'instant_api/controller/parameters'
+        def index
+          parameters = InstantApi::Controller::Parameters.new(params, request.path)
+          collection = InstantApi::Model::Collection.new(#{model_class_name}, parameters)
+          response = {
+            collection: collection.paginated_collection,
+            pagination: {
+              count: collection.count,
+              page: collection.page,
+              per_page: collection.per_page
+            }
+          }
+
+          render json: response
+        end
+      }
+
+      Proc.new { eval body }
+    end
+  end
+end

data/lib/instant_api/controller/build_new.rb

@@ -0,0 +1,22 @@
+module InstantApi::Controller
+  class BuildNew
+
+    def initialize(controller, model_class_name = nil)
+      @controller = controller
+    end
+
+    def build
+      @controller.class_eval(&build_new)
+    end
+
+    private
+
+    def build_new
+      Proc.new do
+        def new
+          head :ok
+        end
+      end
+    end
+  end
+end

data/lib/instant_api/controller/build_resource.rb

@@ -0,0 +1,29 @@
+module InstantApi::Controller
+  class BuildResource
+    def initialize(controller, model_class_name)
+      @controller, @model_class_name = controller, model_class_name
+    end
+
+    def build
+      @controller.class_eval(&build_resource)
+    end
+
+    private
+
+    def build_resource
+      # TODO: extract this require
+      body = %Q{
+        require 'instant_api/model/resource'
+        require 'instant_api/controller/parameters'
+        def resource
+          @resource ||= begin
+            parameters = InstantApi::Controller::Parameters.new(params, request.path)
+            InstantApi::Model::Resource.new(#{@model_class_name}, parameters).find
+          end
+        end
+        private :resource
+      }
+      Proc.new { eval body }
+    end
+  end
+end

data/lib/instant_api/controller/build_show.rb

@@ -0,0 +1,25 @@
+module InstantApi::Controller
+  class BuildShow
+
+    def initialize(controller, model_class_name = nil)
+      @controller = controller
+      @method = 'show'
+    end
+
+    def build
+      @controller.class_eval(&build_method)
+    end
+
+    private
+
+    def build_method
+      body = %Q{
+        def #{@method}
+          render json: resource
+        end
+      }
+
+      Proc.new { eval body }
+    end
+  end
+end

data/lib/instant_api/controller/build_update.rb

@@ -0,0 +1,46 @@
+module InstantApi::Controller
+  class BuildUpdate
+
+    attr_reader :model_class_name, :model_name, :controller
+
+    def initialize(controller, model_class_name)
+      @controller = controller
+      @model_class_name = model_class_name
+      @model_name = model_class_name.underscore
+    end
+
+    def build
+      controller.class_eval(&build_update)
+      controller.class_eval(&build_check_strong_parameters)
+    end
+
+    private
+
+    def build_update
+      Proc.new do
+        def update
+          resource.update_attributes!(check_strong_parameters)
+          raise ActiveRecord::RecordInvalid.new(record) if resource.invalid?
+          render json: resource
+        end
+      end
+    end
+
+    def build_check_strong_parameters
+      body = if model_class_name.constantize.respond_to?(:strong_parameters)
+               "params.require(:#{model_name}).permit(#{model_class_name}.strong_parameters)"
+             else
+               "params.require(:#{model_name}).permit!"
+             end
+
+      Proc.new do
+        eval %Q{
+          def check_strong_parameters
+            #{body}
+          end
+          private :check_strong_parameters
+        }
+      end
+    end
+  end
+end

data/lib/instant_api/controller/builder.rb

@@ -0,0 +1,54 @@
+require 'rails-api'
+require 'instant_api/controller/exception_handler'
+require 'instant_api/controller/build_create'
+require 'instant_api/controller/build_destroy'
+require 'instant_api/controller/build_edit'
+require 'instant_api/controller/build_index'
+require 'instant_api/controller/build_new'
+require 'instant_api/controller/build_resource'
+require 'instant_api/controller/build_update'
+require 'instant_api/controller/build_show'
+
+module InstantApi::Controller
+  class Builder
+
+    attr_reader :controller_name, :method_names
+    def initialize(controller_name, method_names)
+      @controller_name = controller_name
+
+      @method_names = method_names.map(&:to_sym)
+      @method_names << :resource if @method_names != [:index]
+    end
+
+    def build_class
+      controller_class_name = "#{controller_name.camelize}Controller"
+      controller = Class.new(ActionController::API)
+      controller.send(:include, InstantApi::Controller::ExceptionHandler)
+      build_methods(controller)
+
+      Object.const_set(controller_class_name, controller)
+    end
+
+    private
+
+    CLASSES = {
+      create:   InstantApi::Controller::BuildCreate,
+      destroy:  InstantApi::Controller::BuildDestroy,
+      edit:     InstantApi::Controller::BuildEdit,
+      update:   InstantApi::Controller::BuildUpdate,
+      index:    InstantApi::Controller::BuildIndex,
+      new:      InstantApi::Controller::BuildNew,
+      show:     InstantApi::Controller::BuildShow,
+      edit:     InstantApi::Controller::BuildEdit,
+      resource: InstantApi::Controller::BuildResource
+    }
+
+    def build_methods(controller)
+      model_class_name = controller_name.camelize.singularize
+      method_names.each do |name|
+        clasz = CLASSES[name]
+        clasz.new(controller, model_class_name).build
+      end
+    end
+  end
+end

data/lib/instant_api/controller/exception_handler.rb

@@ -0,0 +1,38 @@
+require 'instant_api'
+require 'active_record/validations'
+
+module InstantApi::Controller
+  module ExceptionHandler
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from Exception, with: :render_error
+      rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+      rescue_from ActionController::RoutingError, with: :record_not_found
+      rescue_from ActionController::UnknownController, with: :record_not_found
+      rescue_from ActiveRecord::RecordInvalid, with: :rescue_record_invalid
+    end
+
+    def record_not_found(exception)
+      render json: exception_to_json(exception), status: 404
+    end
+
+    def render_error(exception)
+      render json: exception, status: 500
+    end
+
+    def rescue_record_invalid(exception)
+      render json: exception_to_json(exception), status: 422
+    end
+
+    def exception_to_json(exception)
+      hash =  case exception
+              when ActiveRecord::RecordNotFound
+                {field: :id, message: exception.message}
+              when ActiveRecord::RecordInvalid
+                exception.record.errors.messages.to_a
+              end
+      { errors: hash }
+    end
+  end
+end

data/lib/instant_api/controller/parameters.rb

@@ -0,0 +1,43 @@
+module InstantApi::Controller
+  class Parameters
+    INTERNAL_PARAMS = %w(controller action format _method only_path)
+    RAILS_METHODS = %i(new edit)
+
+    attr_reader :params, :request_path
+
+    # params is the rails params  {"actionF"=>"index", "controller"=>"countries", "id" => 3}
+    # request: /users/2/addresses/3/edit
+    def initialize(params, request_path)
+      @params = params.except(*INTERNAL_PARAMS)
+      @request_path = request_path
+    end
+
+    def [](key)
+      params[key]
+    end
+
+    def select(&block)
+      params.select(&block)
+    end
+
+    # '/users/2/addresses/3/edit' -> [:users, :addresses]
+    def resources
+      @resources ||= begin
+        resources = request_path.strip.
+                                 split('/').
+                                 compact.
+                                 map(&:strip).
+                                 each_with_index.
+                                 select { |_, index| index % 2 == 1 }.
+                                 map { |a, _| a.to_sym }
+
+        *rest, tail = *resources
+        if RAILS_METHODS.index(tail)
+          rest
+        else
+          resources
+        end
+      end
+    end
+  end
+end

data/lib/instant_api/controller/routes.rb

@@ -0,0 +1,46 @@
+require 'action_dispatch/routing/inspector'
+require 'instant_api/controller/builder'
+
+module InstantApi::Controller
+  class Routes
+
+    def initialize
+      Rails.application.reload_routes!
+      @routes = Rails.application.routes.routes.map do |route|
+        ActionDispatch::Routing::RouteWrapper.new(route)
+      end.reject(&:internal?)
+    end
+
+    def build_controllers
+      controllers_by_routes = Hash.new
+      @routes.each do |route|
+        controller = route.defaults[:controller]
+        list = controllers_by_routes[controller] || []
+        controllers_by_routes[controller] = list << route
+      end
+
+      controllers = controllers_by_routes.map do |controller, routes|
+        methods = routes.map { |route| route.defaults[:action] }
+        [controller, methods]
+      end
+
+      controllers.each do |controller, methods|
+        InstantApi::Controller::Builder.new(controller, methods).build_class
+      end
+    end
+  end
+end
+
+
+
+=begin
+routes.each do |route|
+puts [ route.name,
+       route.verb,
+       route.path,
+       route.reqs,
+       route.defaults[:action],
+       route.defaults[:controller],
+       route.json_regexp].join(' - ')
+end;nil
+=end

data/lib/instant_api/model/active_record_query_builder.rb

@@ -0,0 +1,36 @@
+require 'instant_api/model/association_reflector'
+
+module InstantApi::Model
+  class ActiveRecordQueryBuilder
+    attr_reader :model
+    def initialize(model)
+      @model = model
+    end
+
+    def query(params)
+      if has_associations?(params)
+        reflector = InstantApi::Model::AssociationReflector.new(params.resources)
+        model.joins(reflector.calculate_join).
+              where(reflector.calculate_conditions(params))
+      else
+        model.all
+      end
+    end
+
+    def find_first(params)
+      result = if has_associations?(params)
+                 query(params).first
+               else
+                 model.find(params[:id])
+               end
+      raise ActiveRecord::RecordNotFound.new if !result
+      result
+    end
+
+    private
+
+    def has_associations?(params)
+      params.resources.size > 1
+    end
+  end
+end

data/lib/instant_api/model/association_reflector.rb

@@ -0,0 +1,93 @@
+
+#params.resources: [:users, :addresses]
+#request path: /users/1/addresses
+# query: Address.joins(:users)
+
+# has_many
+# has_one
+# belongs_to
+# has_and_belongs_to_many
+# Company
+# has_many :employees
+#  company.employees PLURAL
+# Employee
+# belongs_to :company
+#  employee.company SINGULAR
+# has_one :office
+#  company.office
+# has_and_belongs_to_many
+#  company.offices
+
+
+module InstantApi::Model
+  class AssociationReflector
+
+    def initialize(association_list)
+      @association_list = association_list
+    end
+
+    def calculate_join
+      *associations, resource = *@association_list
+      klass = to_class(resource)
+      first, *rest = *associations.reverse
+
+      result = []
+      if (assoc = association(klass, first))
+        result << assoc.name.to_sym
+        klass = to_class(first)
+      end
+
+      if rest
+        rest.each do |association_name|
+          if (assoc = association(klass, association_name))
+            result << {klass.name.downcase.to_sym => assoc.name.to_sym}
+            klass = to_class(association_name)
+          end
+        end
+      end
+
+      result
+    end
+
+    def calculate_conditions(params)
+      result = Hash.new
+      result[:id] = params[:id] if params[:id]
+
+      resource, *rest = *params.resources
+      klass = to_class(resource)
+      rest.map do |association_name|
+        if (assoc = association(klass, association_name))
+          table = join_table(assoc)
+          foreign_key = foreign_key(assoc)
+          result[table] = { foreign_key => params[foreign_key] }
+        end
+
+        resource = association_name
+        klass = to_class(resource)
+      end
+
+      result
+    end
+
+    def join_table(assoc)
+      if assoc.has_and_belongs_to_many?
+        assoc.join_table.to_sym
+      else
+        assoc.name.to_sym
+      end
+    end
+
+    def foreign_key(assoc)
+      assoc.foreign_key.to_sym
+    end
+
+    def association(klass, name)
+      klass.reflect_on_association(name.to_s.singularize.to_sym) ||
+          klass.reflect_on_association(name.to_s.pluralize.to_sym)
+    end
+
+    def to_class(symbol)
+      symbol.to_s.classify.constantize
+    end
+  end
+end