dynamic_controller 0.0.1 → 0.0.2

data/.gitignore

@@ -1,5 +1,5 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
 .idea

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in dynamic_controller.gemspec
-gemspec
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dynamic_controller.gemspec
+gemspec

data/README.md

@@ -1,6 +1,6 @@
 # DynamicController
 
-Simple way to add CRUD actions to Rails controllers.
+Simple way to add CRUD actions into Rails controllers.
 
 Suppoted formats HTML and JSON.
 
@@ -28,10 +28,47 @@ Or install it yourself as:
 
 has_crud_actions adds index, show, new, edit, create, update and destroy actions to controller
 
+## Explicit action specification
+
+    class UsersController < ApplicationController
+      has_crud_actions only: [:index, :new, :create]
+    end
+
+or
+
+    class UsersController < ApplicationController
+      has_crud_actions except: :destroy
+    end
+
+
 ## Nested resources support
 
     class ProfilesController < ApplicationController
-      has_crud_actions nested_of: User
+      has_crud_actions
+      nested_of: User
+    end
+
+If has more than one nested level should use
+
+    class StreetsController < ApplicationController
+      has_crud_actions
+      nested_of: Country
+      nested_of: City
+    end
+
+## Redefining responder
+
+    class LanguagesController < ApplicationController
+      has_crud_actions
+
+      respond_to_create :html do
+        redirect_to action: :index
+      end
+
+      respond_to_update do |format|
+        format.html { redirect_to action: :index }
+        format.json { render json: @language }
+      end
     end
 
 ## Contributing

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require "bundler/gem_tasks"

data/dynamic_controller.gemspec

@@ -1,26 +1,26 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "dynamic_controller/version"
-
-Gem::Specification.new do |s|
-  s.name        = 'dynamic_controller'
-  s.version     = DynamicController::VERSION
-  s.authors     = ['Gabriel Naiman']
-  s.email       = ['gabynaiman@gmail.com']
-  s.homepage    = 'https://github.com/gabynaiman/dynamic_controller'
-  s.summary     = 'Simple way to add CRUD actions to Rails controllers'
-  s.description = 'Simple way to add CRUD actions to Rails controllers'
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.add_dependency 'ransack'
-  s.add_dependency 'kaminari'
-
-  s.add_development_dependency 'rails'
-  s.add_development_dependency 'sqlite3'
-  s.add_development_dependency 'rspec-rails'
-  s.add_development_dependency 'factory_girl_rails'
-end
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dynamic_controller/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'dynamic_controller'
+  s.version     = DynamicController::VERSION
+  s.authors     = ['Gabriel Naiman']
+  s.email       = ['gabynaiman@gmail.com']
+  s.homepage    = 'https://github.com/gabynaiman/dynamic_controller'
+  s.summary     = 'Simple way to add CRUD actions into Rails controllers'
+  s.description = 'Simple way to add CRUD actions into Rails controllers'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'ransack'
+  s.add_dependency 'kaminari'
+
+  s.add_development_dependency 'rails'
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'rspec-rails'
+  s.add_development_dependency 'factory_girl_rails'
+end

data/lib/dynamic_controller/class_methods.rb

@@ -0,0 +1,48 @@
+module DynamicController
+  module ClassMethods
+    ACTIONS = [:index, :show, :new, :create, :edit, :update, :destroy]
+
+    def has_crud_actions(options={})
+      @resource_options = Hash[options.map { |k, v| [:only, :except].include?(k.to_sym) ? [k, [v].flatten.map(&:to_sym)] : [k, v] }].reverse_merge(only: ACTIONS, except: [])
+      send :include, InstanceMethods
+    end
+
+    def nested_of(resource_class)
+      before_filter :load_parent_models if parent_resources.empty?
+      self.parent_resources << Resource.new(resource_class: resource_class)
+    end
+
+    def parent_resources
+      @parent_resources ||= []
+    end
+
+    def include_action?(action_name)
+      (@resource_options[:only] - @resource_options[:except]).include?(action_name)
+    end
+
+    def redefined_responders
+      @redefined_responders ||= {}
+    end
+
+    def redefined_responder_to(action, format=nil)
+      redefined_responders[redefined_responder_key(action, format)]
+    end
+
+    def redefined_responder_to?(action, format=nil)
+      redefined_responders.has_key? redefined_responder_key(action, format)
+    end
+
+    ACTIONS.each do |action|
+      define_method "respond_to_#{action}" do |format=nil, &block|
+        redefined_responders[redefined_responder_key(action, format)] = block
+      end
+    end
+
+    private
+
+    def redefined_responder_key(action, format=nil)
+      [action, format].compact.join('_').to_sym
+    end
+
+  end
+end

data/lib/dynamic_controller/helper_methods.rb

@@ -0,0 +1,59 @@
+module DynamicController
+  module HelperMethods
+
+    def resource_class
+      @resource_class ||= (resource_namespace.to_s.split('::') << controller_name.classify).join('::').constantize
+    end
+
+    def resource_namespace
+      self.class.to_s.deconstantize.constantize
+    end
+
+    def collection=(value)
+      instance_variable_set("@#{controller_name}", value)
+    end
+
+    def collection
+      instance_variable_get("@#{controller_name}")
+    end
+
+    def model=(value)
+      instance_variable_set("@#{controller_name.singularize}", value)
+    end
+
+    def model
+      instance_variable_get("@#{controller_name.singularize}")
+    end
+
+    def load_parent_models
+      parent = nil
+      self.class.parent_resources.each do |resource|
+        if parent
+          parent = parent.send(resource.children_name).find(params[resource.param_name])
+        else
+          parent = resource.find params[resource.param_name]
+        end
+        instance_variable_set resource.instance_variable_name, parent
+      end
+    end
+
+    def parent_models
+      return nil if self.class.parent_resources.empty?
+      self.class.parent_resources.map do |resource|
+        instance_variable_get resource.instance_variable_name
+      end
+    end
+
+    def parent_model
+      (parent_models || []).last
+    end
+
+    def handle_error(error)
+      respond_to do |format|
+        format.html { raise error }
+        format.json { render json: error.message, status: :internal_server_error }
+      end
+    end
+
+  end
+end

data/lib/dynamic_controller/instance_methods.rb

@@ -0,0 +1,127 @@
+module DynamicController
+  module InstanceMethods
+
+    def self.included(base)
+      base.send :include, HelperMethods
+      base.rescue_from StandardError, with: :handle_error
+
+      if base.include_action?(:index)
+        base.send :define_method, :index do
+          if parent_model
+            self.collection = parent_model.send(controller_name).search(params[:q]).result.page(params[:page])
+          else
+            self.collection = resource_class.search(params[:q]).result.page(params[:page])
+          end
+
+          Responder.new(self).index
+        end
+      end
+
+      if base.include_action?(:show)
+        base.send :define_method, :show do
+          if parent_model
+            self.model = parent_model.send(controller_name).find(params[:id])
+          else
+            self.model = resource_class.find(params[:id])
+          end
+
+          Responder.new(self).show
+        end
+      end
+
+      if base.include_action?(:new)
+        base.send :define_method, :new do
+          if parent_model
+            self.model = parent_model.send(controller_name).build
+          else
+            self.model = resource_class.new
+          end
+
+          Responder.new(self).new
+        end
+      end
+
+      if base.include_action?(:edit)
+        base.send :define_method, :edit do
+          if parent_model
+            self.model = parent_model.send(controller_name).find(params[:id])
+          else
+            self.model = resource_class.find(params[:id])
+          end
+
+          Responder.new(self).edit
+        end
+      end
+
+      if base.include_action?(:create)
+        base.send :define_method, :create do
+          if parent_model
+            self.model = parent_model.send(controller_name).build(params[controller_name.singularize])
+          else
+            self.model = resource_class.new(params[controller_name.singularize])
+          end
+
+          if model.save
+            flash_message = "#{resource_class.model_name.human} successfully created"
+            if params[:save_and_new]
+              flash[:success] = flash_message
+              redirect_to action: :new
+            else
+              flash.now[:success] = flash_message
+              Responder.new(self).create
+            end
+          else
+            respond_to do |format|
+              format.html { render :new }
+              format.json { render json: model.errors, status: :unprocessable_entity }
+            end
+          end
+        end
+      end
+
+      if base.include_action?(:update)
+        base.send :define_method, :update do
+          if parent_model
+            self.model = parent_model.send(controller_name).find(params[:id])
+          else
+            self.model = resource_class.find(params[:id])
+          end
+
+          if model.update_attributes(params[controller_name.singularize])
+            flash.now[:success] = "#{resource_class.model_name.human} successfully updated"
+            Responder.new(self).update
+          else
+            respond_to do |format|
+              format.html { render :edit }
+              format.json { render json: model.errors, status: :unprocessable_entity }
+            end
+          end
+        end
+
+      end
+
+      if base.include_action?(:destroy)
+        base.send :define_method, :destroy do
+          if parent_model
+            self.model = parent_model.send(controller_name).find(params[:id])
+          else
+            self.model = resource_class.find(params[:id])
+          end
+
+          if model.destroy
+            flash[:warning] = "#{resource_class.model_name.human} successfully removed"
+            Responder.new(self).destroy
+          else
+            flash[:danger] = "#{resource_class.model_name.human} could not be deleted"
+            respond_to do |format|
+              format.html { redirect_to action: :index }
+              format.json { render json: model.errors, status: :unprocessable_entity }
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dynamic_controller/resource.rb

@@ -0,0 +1,21 @@
+module DynamicController
+  class Resource
+    attr_reader :resource_class,
+                :param_name,
+                :instance_variable_name,
+                :children_name
+
+    def initialize(options={})
+      raise 'Param resource_class must be a class' if !options.has_key?(:resource_class) || !options[:resource_class].is_a?(Class)
+      @resource_class = options[:resource_class]
+      @param_name = options[:param_name] || "#{resource_class.to_s.demodulize.underscore}_id"
+      @instance_variable_name = options[:instance_variable_name] || "@#{resource_class.to_s.demodulize.underscore}"
+      @children_name = options[:children_name] || resource_class.to_s.demodulize.pluralize.underscore
+    end
+
+    def find(id)
+      resource_class.find(id)
+    end
+
+  end
+end

data/lib/dynamic_controller/responder.rb

@@ -0,0 +1,71 @@
+module DynamicController
+  class Responder
+
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def index
+      action :index,
+             html: Proc.new {},
+             json: Proc.new { render json: collection }
+    end
+
+    def show
+      action :show,
+             html: Proc.new {},
+             json: Proc.new { render json: model }
+    end
+
+    def new
+      action :new,
+             html: Proc.new {}
+    end
+
+    def edit
+      action :edit,
+             html: Proc.new {}
+    end
+
+    def create
+      action :create,
+             html: Proc.new { redirect_to action: :show, id: model.id },
+             json: Proc.new { render json: model, status: :created }
+    end
+
+    def update
+      action :update,
+             html: Proc.new { redirect_to action: :show, id: model.id },
+             json: Proc.new { head :no_content }
+    end
+
+    def destroy
+      action :destroy,
+             html: Proc.new { redirect_to action: :index },
+             json: Proc.new { head :no_content }
+    end
+
+    private
+
+    def action(name, blocks={})
+      @controller.instance_eval do
+        if self.class.redefined_responder_to?(name)
+          respond_to do |format|
+            self.instance_exec format, &self.class.redefined_responder_to(name)
+          end
+        else
+          respond_to do |format|
+            [:html, :json].each do |mime|
+              if self.class.redefined_responder_to?(name, mime)
+                format.send(mime) { self.instance_eval &self.class.redefined_responder_to(name, mime) }
+              elsif blocks[mime]
+                format.send(mime) { self.instance_eval &blocks[mime] }
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/dynamic_controller/version.rb

@@ -1,3 +1,3 @@
-module DynamicController
-  VERSION = "0.0.1"
-end
+module DynamicController
+  VERSION = "0.0.2"
+end

data/lib/dynamic_controller.rb

@@ -1,180 +1,12 @@
-require 'dynamic_controller/version'
-require 'ransack'
-require 'kaminari'
-
-module DynamicController
-
-  module ClassMethods
-
-    attr_reader :dynamic_options
-
-    def has_crud_actions(options={})
-      send :include, CrudActions
-      before_filter :load_nested if options[:nested_of]
-      @dynamic_options = options
-    end
-
-  end
-
-  module CrudActions
-
-    def self.included(base)
-      base.helper_method [:resource_class, :controller_namespace]
-      base.respond_to :html, :json
-      base.rescue_from StandardError, with: :handle_error
-    end
-
-    def index
-      if parent_model
-        self.collection = parent_model.send(controller_name).search(params[:q]).result.page(params[:page])
-      else
-        self.collection = resource_class.search(params[:q]).result.page(params[:page])
-      end
-
-      respond_with collection
-    end
-
-    def show
-      if parent_model
-        self.model = parent_model.send(controller_name).find(params[:id])
-      else
-        self.model = resource_class.find(params[:id])
-      end
-
-      respond_with model
-    end
-
-    def new
-      if parent_model
-        self.model = parent_model.send(controller_name).build
-      else
-        self.model = resource_class.new
-      end
-    end
-
-    def edit
-      if parent_model
-        self.model = parent_model.send(controller_name).find(params[:id])
-      else
-        self.model = resource_class.find(params[:id])
-      end
-    end
-
-    def create
-      if parent_model
-        self.model = parent_model.send(controller_name).build(params[resource_class.model_name.underscore])
-      else
-        self.model = resource_class.new(params[resource_class.model_name.underscore])
-      end
-
-      if model.save
-        flash_message = "#{resource_class.model_name.human} successfully created"
-        if params[:save_and_new]
-          flash[:success] = flash_message
-          redirect_to action: :new
-        else
-          flash.now[:success] = flash_message
-          respond_to do |format|
-            format.html { redirect_to url_for([parent_model, model].compact) }
-            format.json { render json: model, status: :created }
-          end
-        end
-      else
-        respond_to do |format|
-          format.html { render :new }
-          format.json { render json: model.errors, status: :unprocessable_entity }
-        end
-      end
-    end
-
-    def update
-      if parent_model
-        self.model = parent_model.send(controller_name).find(params[:id])
-      else
-        self.model = resource_class.find(params[:id])
-      end
-
-      if model.update_attributes(params[resource_class.model_name.underscore])
-        flash.now[:success] = "#{resource_class.model_name.human} successfully updated"
-        respond_to do |format|
-          format.html { redirect_to url_for([parent_model, model].compact) }
-          format.json { head :no_content }
-        end
-      else
-        respond_to do |format|
-          format.html { render :edit }
-          format.json { render json: model.errors, status: :unprocessable_entity }
-        end
-      end
-    end
-
-    def destroy
-      if parent_model
-        self.model = parent_model.send(controller_name).find(params[:id])
-      else
-        self.model = resource_class.find(params[:id])
-      end
-
-      if model.destroy
-        flash[:warning] = "#{resource_class.model_name.human} successfully removed"
-        respond_to do |format|
-          format.html { redirect_to action: :index }
-          format.json { head :no_content }
-        end
-      else
-        flash[:danger] = "#{resource_class.model_name.human} could not be deleted"
-        respond_to do |format|
-          format.html { redirect_to action: :index }
-          format.json { render json: model.errors, status: :unprocessable_entity }
-        end
-      end
-    end
-
-    def resource_class
-      @resource_class ||= controller_name.classify.constantize
-    end
-
-    def controller_namespace
-      @controller_namespace ||= self.class.name.split('::')[0..-2].map(&:underscore).join('_') unless self.class.name.split('::')[0..-2].empty?
-    end
-
-    private
-
-    def collection=(value)
-      instance_variable_set("@#{controller_name}", value)
-    end
-
-    def collection
-      instance_variable_get("@#{controller_name}")
-    end
-
-    def model=(value)
-      instance_variable_set("@#{controller_name.singularize}", value)
-    end
-
-    def model
-      instance_variable_get("@#{controller_name.singularize}")
-    end
-
-    def load_nested
-      parent_klass = self.class.dynamic_options[:nested_of]
-      instance_variable_set("@#{parent_klass.to_s.underscore}", parent_klass.find(params["#{parent_klass.to_s.underscore}_id"]))
-    end
-
-    def parent_model
-      instance_variable_get("@#{self.class.dynamic_options[:nested_of].to_s.underscore}")
-    end
-
-    def handle_error(error)
-      respond_to do |format|
-        format.html { raise error }
-        format.json { render json: error.message, status: :internal_server_error }
-      end
-    end
-
-  end
-
-end
-
-ActionController::Base.send :extend, DynamicController::ClassMethods
-
+require 'ransack'
+require 'kaminari'
+
+require 'dynamic_controller/version'
+require 'dynamic_controller/resource'
+require 'dynamic_controller/responder'
+require 'dynamic_controller/helper_methods'
+require 'dynamic_controller/class_methods'
+require 'dynamic_controller/instance_methods'
+
+ActionController::Base.send :extend, DynamicController::ClassMethods
+

data/spec/controller_factory.rb

@@ -0,0 +1,15 @@
+class AllActionsController < ActionController::Base
+  has_crud_actions
+end
+
+class OnlyIndexController < ActionController::Base
+  has_crud_actions only: :index
+end
+
+class ExceptIndexController < ActionController::Base
+  has_crud_actions except: :index
+end
+
+class OnlyAndExceptController < ActionController::Base
+  has_crud_actions only: [:index, :new, :create, :edit], except: [:edit, :destroy]
+end