programmable_scaffold_rails 0.0.2

data/lib/programmable_scaffold_rails/config.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+require 'active_support'
+require 'active_support/core_ext'
+
+module ProgrammableScaffoldRails
+  CRUD_METHODS = [ :new,
+                   :create,
+                   :index,
+                   :show,
+                   :edit,
+                   :update,
+                   :destroy ].freeze
+
+  BASE_OPTIONS = HashWithIndifferentAccess.new(YAML.load(File.read(File.expand_path('../../../config/action_controller.yml', __FILE__))))
+end

data/lib/programmable_scaffold_rails/engine.rb

@@ -0,0 +1,6 @@
+require 'rails'
+
+module ProgrammableScaffoldRails #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+  end
+end

data/lib/programmable_scaffold_rails/scaffold/create.rb

@@ -0,0 +1,51 @@
+require 'programmable_scaffold_rails/action_controller_helpers'
+
+module ProgrammableScaffoldRails
+
+  module Scaffold
+
+    module Create
+
+      def create
+        scaffold_helper = self.programmable_scaffold_controller_helpers
+        self.instance_variable_set(scaffold_helper.single_instance,
+                                   scaffold_helper.klass.new(
+                                     scaffold_helper.call_strong_params
+                                   ))
+        instance = self.instance_variable_get(scaffold_helper.single_instance)
+        authorize!(:create, instance) if scaffold_helper.cancan
+
+        respond_to do |format|
+          if instance.save
+            scaffold_helper.formats.each do |used_format|
+              case used_format
+              when :html
+                format.html { redirect_to scaffold_helper.after_create_url(instance),
+                                          notice: I18n.t('programmable_scaffold_rails.after_create_notice',
+                                                         model_class: instance.class.model_name.human) }
+              when :json
+                format.json { render action: 'show', status: :created, location: instance }
+              end
+            end
+          else
+            scaffold_helper.formats.each do |used_format|
+              case used_format
+              when :html
+                format.html do
+                  flash[:alert] = I18n.t('programmable_scaffold_rails.after_create_alert',
+                                         model_class: instance.class.model_name.human)
+                  render action: 'new'
+                end
+              when :json
+                format.json { render json: instance.errors, status: :unprocessable_entity }
+              end
+            end
+          end
+        end
+      end
+      
+    end
+
+  end
+
+end

data/lib/programmable_scaffold_rails/scaffold/destroy.rb

@@ -0,0 +1,53 @@
+require 'programmable_scaffold_rails/action_controller_helpers'
+
+module ProgrammableScaffoldRails
+
+  module Scaffold
+
+    module Destroy
+
+      def destroy
+        scaffold_helper = self.programmable_scaffold_controller_helpers
+        self.instance_variable_set(scaffold_helper.single_instance,
+                                   scaffold_helper.find_by_id_or_friendly_id(params))
+        instance = self.instance_variable_get(scaffold_helper.single_instance)
+        authorize!(:destroy, instance) if scaffold_helper.cancan
+
+        if instance.destroy
+          respond_to do |format|
+            scaffold_helper.formats.each do |used_format|
+              case used_format
+              when :html
+                format.html { redirect_to scaffold_helper.after_destroy_url(instance),
+                                          notice: I18n.t('programmable_scaffold_rails.after_destroy_notice',
+                                                         model_class: instance.class.model_name.human) }
+              when :json
+                format.json { head :no_content }
+              end
+            end
+          end
+        else
+          respond_to do |format|
+            scaffold_helper.formats.each do |used_format|
+              case used_format
+              when :html
+                # XXX: Check if redirect_to :back doesn't create issues with failing
+                #      destroy and redirect loops
+                format.html do
+                  flash[:alert] = I18n.t('programmable_scaffold_rails.after_destroy_alert',
+                                         model_class: instance.class.model_name.human)
+                  redirect_to :back
+                end
+              when :json
+                format.json { render json: instance.errors, status: :unprocessable_entity }
+              end
+            end
+          end
+        end
+      end
+      
+    end
+
+  end
+
+end

data/lib/programmable_scaffold_rails/scaffold/edit.rb

@@ -0,0 +1,21 @@
+require 'programmable_scaffold_rails/action_controller_helpers'
+
+module ProgrammableScaffoldRails
+
+  module Scaffold
+
+    module Edit
+
+      def edit
+        scaffold_helper = self.programmable_scaffold_controller_helpers
+        self.instance_variable_set(scaffold_helper.single_instance,
+                                   scaffold_helper.find_by_id_or_friendly_id(params))
+        instance = self.instance_variable_get(scaffold_helper.single_instance)
+        authorize!(:update, instance) if scaffold_helper.cancan
+      end
+      
+    end
+
+  end
+
+end

data/lib/programmable_scaffold_rails/scaffold/index.rb

@@ -0,0 +1,20 @@
+require 'programmable_scaffold_rails/action_controller_helpers'
+
+module ProgrammableScaffoldRails
+
+  module Scaffold
+
+    module Index
+
+      def index
+        scaffold_helper = self.programmable_scaffold_controller_helpers
+        self.instance_variable_set(scaffold_helper.multiple_instances,
+                                   scaffold_helper.klass.all)
+        authorize!(:read, scaffold_helper.klass) if scaffold_helper.cancan
+      end
+      
+    end
+
+  end
+
+end

data/lib/programmable_scaffold_rails/scaffold/new.rb

@@ -0,0 +1,21 @@
+require 'programmable_scaffold_rails/action_controller_helpers'
+
+module ProgrammableScaffoldRails
+
+  module Scaffold
+
+    module New
+
+      def new
+        scaffold_helper = self.programmable_scaffold_controller_helpers
+        self.instance_variable_set(scaffold_helper.single_instance,
+                                   scaffold_helper.klass.new)
+        instance = self.instance_variable_get(scaffold_helper.single_instance)
+        authorize!(:create, instance) if scaffold_helper.cancan
+      end
+      
+    end
+
+  end
+
+end

data/lib/programmable_scaffold_rails/scaffold/show.rb

@@ -0,0 +1,21 @@
+require 'programmable_scaffold_rails/action_controller_helpers'
+
+module ProgrammableScaffoldRails
+
+  module Scaffold
+
+    module Show
+
+      def show
+        scaffold_helper = self.programmable_scaffold_controller_helpers
+        self.instance_variable_set(scaffold_helper.single_instance,
+                                   scaffold_helper.find_by_id_or_friendly_id(params))
+        instance = self.instance_variable_get(scaffold_helper.single_instance)
+        authorize!(:read, instance) if scaffold_helper.cancan
+      end
+      
+    end
+
+  end
+
+end

data/lib/programmable_scaffold_rails/scaffold/update.rb

@@ -0,0 +1,49 @@
+require 'programmable_scaffold_rails/action_controller_helpers'
+
+module ProgrammableScaffoldRails
+
+  module Scaffold
+
+    module Update
+
+      def update
+        scaffold_helper = self.programmable_scaffold_controller_helpers
+        self.instance_variable_set(scaffold_helper.single_instance,
+                                   scaffold_helper.find_by_id_or_friendly_id(params))
+        instance = self.instance_variable_get(scaffold_helper.single_instance)
+        authorize!(:update, instance) if scaffold_helper.cancan
+        
+        respond_to do |format|
+          if instance.update(scaffold_helper.call_strong_params)
+            scaffold_helper.formats.each do |used_format|
+              case used_format
+              when :html
+                format.html { redirect_to scaffold_helper.after_update_url(instance),
+                                          notice: I18n.t('programmable_scaffold_rails.after_update_notice',
+                                                         model_class: instance.class.model_name.human) }
+              when :json
+                format.json { head :no_content }
+              end
+            end
+          else
+            scaffold_helper.formats.each do |used_format|
+              case used_format
+              when :html
+                format.html do
+                  flash.alert = I18n.t('programmable_scaffold_rails.after_update_alert',
+                                       model_class: instance.class.model_name.human)
+                  render action: 'edit'
+                end
+              when :json
+                format.json { render json: instance.errors, status: :unprocessable_entity }
+              end
+            end
+          end
+        end
+      end
+      
+    end
+
+  end
+
+end

data/lib/programmable_scaffold_rails/version.rb

@@ -0,0 +1,3 @@
+module ProgrammableScaffoldRails
+  VERSION = "0.0.2"
+end

data/programmable_scaffold_rails.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'programmable_scaffold_rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "programmable_scaffold_rails"
+  spec.version       = ProgrammableScaffoldRails::VERSION
+  spec.authors       = ["Fire-Dragon-DoL"]
+  spec.email         = ["francesco.belladonna@gmail.com"]
+  spec.description   = %q{This gem should support you when using rails scaffold (or a lot of simple CRUD models/views/controllers) in a programmable fashion, removing repeated code when possible and making it configurable}
+  spec.summary       = %q{This gem should remove repeated code when using Rails scaffold}
+  spec.homepage      = "https://github.com/Fire-Dragon-DoL/programmable_scaffold_rails"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "i18n",          "~> 0.6.5"
+  spec.add_dependency "rails",         "~> 4.0.0"
+  spec.add_dependency "activesupport", "~> 4.0.0"
+
+  spec.add_development_dependency "bundler",          "~> 1.3"
+  spec.add_development_dependency "rspec",            "~> 2.14.0"
+  spec.add_development_dependency "combustion",       "~> 0.5.1"
+  spec.add_development_dependency "sqlite3",          "~> 1.3.8"
+  spec.add_development_dependency "faker",            "~> 1.2.0"
+  spec.add_development_dependency "factory_girl",     "~> 4.3.0"
+  spec.add_development_dependency "database_cleaner", "~> 1.2.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+end

data/spec/action_controller_extensions.rb_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'programmable_scaffold_rails/action_controller_extensions'
+
+describe ProgrammableScaffoldRails::ActionControllerExtensions do
+  let(:controller_class) do
+    Class.new do
+      include ::ProgrammableScaffoldRails::ActionControllerExtensions
+    end
+  end
+  # XXX: let order it's random, be careful with duping from other "lets"
+  let(:controller_class_with_scaffold) do
+    Class.new do
+      include ::ProgrammableScaffoldRails::ActionControllerExtensions
+
+      programmable_scaffold
+    end
+  end
+
+  it { controller_class.should respond_to(:programmable_scaffold) }
+
+  it "does not allow to use :extend and :only at same time in programmable_scaffold" do
+    expect do
+      controller_class.dup.class_eval do
+        programmable_scaffold only: [], except: []
+      end
+    end.to raise_error
+  end
+
+  it "does not have included Scaffold::New module because of the :only option" do
+    # XXX: Be careful, testing against #new method can be tricky because it
+    #      it exists on all objects
+    controller_class.dup.class_eval do
+      programmable_scaffold only: [:create]
+    end.included_modules.should_not include(::ProgrammableScaffoldRails::Scaffold::New)
+  end
+
+  it "does not have included Scaffold::Create module because of the :except option" do
+    controller_class.dup.class_eval do
+      programmable_scaffold except: [:new]
+    end.included_modules.should_not include(::ProgrammableScaffoldRails::Scaffold::New)
+  end
+
+  context "with scaffold methods" do
+    subject(:controller) do
+      obj = controller_class_with_scaffold.new
+      obj.stub(:controller_name).and_return('stubbeds')
+
+      obj
+    end
+      specify { controller.should respond_to(:new)     }
+      specify { controller.should respond_to(:create)  }
+      specify { controller.should respond_to(:index)   }
+      specify { controller.should respond_to(:show)    }
+      specify { controller.should respond_to(:edit)    }
+      specify { controller.should respond_to(:update)  }
+      specify { controller.should respond_to(:destroy) }
+
+  end
+
+end

data/spec/action_controller_helpers_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'programmable_scaffold_rails/action_controller_helpers'
+require 'internal/app/models/dummy'
+
+describe ProgrammableScaffoldRails::ActionControllerHelpers do
+  class Stubbed
+  end
+
+  let(:controller_class_with_scaffold) do
+    Class.new do
+      include ::ProgrammableScaffoldRails::ActionControllerExtensions
+      programmable_scaffold
+    end
+  end
+  let(:controller) do
+    obj = controller_class_with_scaffold.new
+    obj.stub(:controller_name).and_return('stubbeds')
+
+    obj
+  end
+  let(:allowed_after_actions) { [nil, :edit, :show] }
+
+  it { controller.should respond_to(:programmable_scaffold_controller_helpers) }
+
+  subject(:controller_helpers) { controller.programmable_scaffold_controller_helpers }
+    specify { controller_helpers.should respond_to(:klass)                   }
+    specify { controller_helpers.should respond_to(:table)                   }
+    specify { controller_helpers.should respond_to(:single_instance_name)    }
+    specify { controller_helpers.should respond_to(:single_instance)         }
+    specify { controller_helpers.should respond_to(:multiple_instances_name) }
+    specify { controller_helpers.should respond_to(:multiple_instances)      }
+    specify { controller_helpers.should respond_to(:url_namespace)           }
+    specify { controller_helpers.should respond_to(:friendly_id)             }
+    specify { controller_helpers.should respond_to(:strong_params)           }
+    specify { controller_helpers.should respond_to(:call_strong_params)      }
+    specify { controller_helpers.should respond_to(:cancan)                  }
+    specify { controller_helpers.should respond_to(:after_create_action)     }
+    specify { controller_helpers.should respond_to(:after_update_action)     }
+    specify { controller_helpers.should respond_to(:after_update_url)        }
+    specify { controller_helpers.should respond_to(:after_create_url)        }
+    specify { controller_helpers.should respond_to(:after_destroy_url)       }
+    specify { controller_helpers.should respond_to(:formats)                 }
+    specify { controller_helpers.klass.should be Stubbed                     }
+    specify { controller_helpers.table.should be :stubbeds                   }
+    specify { controller_helpers.single_instance_name.should be :stubbed     }
+    specify { controller_helpers.single_instance.should be :@stubbed         }
+    specify { controller_helpers.multiple_instances_name.should be :stubbeds }
+    specify { controller_helpers.multiple_instances.should be :@stubbeds     }
+    specify { controller_helpers.url_namespace.should match ''               }
+    specify { controller_helpers.friendly_id.should be_false                 }
+    specify { controller_helpers.strong_params.should be :model_params       }
+    specify { controller_helpers.cancan.should be_true                       }
+    specify { allowed_after_actions.should include(controller_helpers.after_create_action) }
+    specify { allowed_after_actions.should include(controller_helpers.after_update_action) }
+    specify { controller_helpers.formats.should match_array([:html, :json]) }
+
+  it "is valid to use nil as after_create_action" do
+    controller_helpers.stub(:after_create_action).and_return(nil)
+    allowed_after_actions.should include(controller_helpers.after_create_action)
+  end
+
+  it "is valid to use nil as after_update_action" do
+    controller_helpers.stub(:after_update_action).and_return(nil)
+    allowed_after_actions.should include(controller_helpers.after_update_action)
+  end
+
+  it "has not implemented strong_params method that will be called" do
+    expect do
+      controller_helpers.call_strong_params
+    end.to raise_error(NotImplementedError)
+  end
+
+  context "when searching in database" do
+    subject(:dummy_model) { Stubbed.new }
+
+    it "can search item without slug" do
+      controller_helpers.stub_chain('klass.find').and_return(dummy_model)
+
+      controller_helpers.find_by_id_or_friendly_id({ id: 1 }).should be dummy_model
+    end
+
+    it "can search item with slug" do
+      controller_helpers.stub(:friendly_id).and_return(true)
+      controller_helpers.stub_chain('klass.friendly.find').and_return(dummy_model)
+
+      controller_helpers.find_by_id_or_friendly_id({ id: 'dummy' }).should be dummy_model
+    end    
+  end
+
+end