programmable_scaffold_rails 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1fd5eead3a11c4c4b4856264e9ce633d12aad3a6
+  data.tar.gz: 5bb03a34bfad4492c8a98c1e9463eec0fd127ddc
+SHA512:
+  metadata.gz: 4770bb93ac76bd5b5ff6c2bded6b17630953bb13eb85732e6905bca7b800bf9d01e588f42e7fa6a78487b6940fcbb175a0cc5540fc6a8130460083f2fb2f20fa
+  data.tar.gz: 6c85ce9fc00f26d97b96334111d8efa29fba7d26e83729cb53fffb6b89d6b7fc0ab78f94dfcbc99e0ec2f52d8498a9ac6d26ac72d1b2f035924d80f91239be69

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p247

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in programmable_scaffold_rails.gemspec
+gemspec
+
+group :test do
+  gem 'sqlite3',      '~> 1.3.8'
+  gem 'activerecord', '~> 4.0.1'
+  gem 'actionpack',   '~> 4.0.1'
+  gem 'rspec-rails',  '~> 2.14', require: false
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Fire-Dragon-DoL
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,116 @@
+# ProgrammableScaffoldRails
+
+This gem should remove repeated code when rails scaffolding, expecially on controllers.  
+It's useful when you are prototyping and when you are just building an application with a lot of simple **CRUD**.  
+It's also configurable, to avoid as most as possible to completely override one of the default controllers method, unless you are doing something really special.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'programmable_scaffold_rails', '~> 0.0.2'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install programmable_scaffold_rails
+
+## Usage
+
+In your Controller (or in ApplicationController if you want it application wise)
+include the module:
+
+```ruby
+include ProgrammableScaffoldRails::ActionControllerExtensions
+```
+
+Now you have the class method `programmable_scaffold` available.  
+This method should be run once per controller where you want to use it
+(options are inherited and can be overridden!). It will create each required
+action to have a controller working correctly like if just generated with rails scaffolding.
+All options have already default values, you can call the method without passing anything to it.
+
+If you want have an idea on how it's working, I suggest you to check the
+[Rails application](https://github.com/Fire-Dragon-DoL/programmable_scaffold_rails/tree/master/spec/internal)
+used internally for specs.
+
+### Available options
+| Name | Type | Default | Notes |
+|------|------|---------|-------|
+| class\_name | String | `controller.controller_name.to_s` | If set, replace the auto-calculated model class name |
+| table\_name | String | `class_name.tableize` | This is used to name instance variables of a model, if set, it won't be auto-calculated |
+| single\_instance\_name | String | `table_name.singularize` | Used when setting the instance variable for actions such as `new`, `edit`, `show`, `create`, `update` and `destroy` which can be used in the view |
+| multiple\_instances\_name | String | `table_name.pluralize` | Used when setting the instance variable for action such as `index` which can be used in the view |
+| cancan | bool | true | Enable cancan support which calls authorize! before each CRUD action |
+| friendly\_id | bool | false | Enable `friendly_id` support, if your model uses `friendly_id`, that will be used for finding the model object |
+| strong\_params | Symbol | :model_params | Name of existing method in controller, which should return params hash filtered by strong_parameters |
+| url_\namespace | String | Empty string | When generating urls for `after_create_url`, `after_update_url` and `after_destroy_url`, a namespace will be prepended if this is set |
+| after\_create\_action | Nil/Symbol | :show | One of `nil`, `:show`, `:edit`. `nil` and `:show` are the same |
+| after\_update\_action | Nil/Symbol | :show | See `after_create_action` |
+| after\_create\_url | Nil/Symbol/Proc/String | nil | If `nil` is set, the url will be auto generated with `url_namespace` and using the `after_create_action` for the given model object. If `Symbol` is used, a method with that name will be searched in controller and called with model instance as argument, it must generate a valid url. If proc is used, it will be called with model instance as argument. If a `String` is used, it will be directly passed to `url_for` to generate an url |
+| after\_update\_url | Nil/Symbol/Proc/String | nil | See `after_create_url` |
+| after\_destroy\_url | Nil/Symbol/Proc/String | nil | See `after_destroy_url` |
+| formats | Array of Symbols | [:html, :json] | Formats returned by the CRUD actions for controller |
+
+### Example
+
+```ruby
+# app/models/dummy.rb
+
+class Dummy < ActiveRecord::Base
+  # column name: :string
+end
+```
+
+```ruby
+# app/controllers/dummies_controller.rb
+
+class DummiesController < ApplicationController
+  include ProgrammableScaffoldRails::ActionControllerExtensions
+
+  programmable_scaffold class_name: 'Dummy',
+                        table_name: 'dummies'
+
+  def model_params
+    params.require(:dummy).permit(:name)
+  end
+end
+```
+
+### I18n
+
+You can change these keys in your locales to have your application easily localized:
+
+| Key | Value |
+|-----|-------|
+| `programmable_scaffold_rails.after_create_notice`  | %{model_class} was successfully created.   |
+| `programmable_scaffold_rails.after_update_notice`  | %{model_class} was successfully updated.   |
+| `programmable_scaffold_rails.after_destroy_notice` | %{model_class} was successfully destroyed. |
+| `programmable_scaffold_rails.after_create_alert`   | %{model_class} cannot be created.          |
+| `programmable_scaffold_rails.after_update_alert`   | %{model_class} cannot be updated.          |
+| `programmable_scaffold_rails.after_destroy_alert`  | %{model_class} cannot be destroyed.        |
+
+#### Regarding model_class
+
+Model class is auto-calculated with  `model_instance.class.model_name.human`, if you localize your model
+class following rails standards, you shouldn't have any problem.
+
+## Features
+
+- `I18n` messages for successfully or failed action
+- [friendly_id](https://github.com/norman/friendly_id) support
+
+# TODO
+
+- Add I18n keys to completely replace those with `model_class`, if for example someone want to insert custom messages for each controller, something like `programmable_scaffold_rails.<controller_name>.after_create_notice`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/config.ru

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default, :development
+
+Combustion.initialize! :active_record,
+                       :action_controller,
+                       :action_view
+run Combustion::Application

data/config/action_controller.yml

@@ -0,0 +1,12 @@
+cancan:              true
+friendly_id:         false
+strong_params:       :model_params
+# nil is used for :show (both can be used)
+after_create_action: :show
+after_update_action: :show
+after_update_url:    ~
+after_create_url:    ~
+after_destroy_url:   ~
+formats:
+  - :html
+  - :json

data/config/locales/en.yml

@@ -0,0 +1,8 @@
+en:
+  programmable_scaffold_rails:
+    after_create_notice:  "%{model_class} was successfully created."
+    after_update_notice:  "%{model_class} was successfully updated."
+    after_destroy_notice: "%{model_class} was successfully destroyed."
+    after_create_alert:   "%{model_class} cannot be created."
+    after_update_alert:   "%{model_class} cannot be updated."
+    after_destroy_alert:  "%{model_class} cannot be destroyed."

data/lib/programmable_scaffold_rails.rb

@@ -0,0 +1,17 @@
+require 'programmable_scaffold_rails/version'
+require 'programmable_scaffold_rails/config'
+require 'programmable_scaffold_rails/action_controller_extensions'
+
+module ProgrammableScaffoldRails #:nodoc
+end
+
+# load Rails/Railtie
+begin
+  require 'rails'
+rescue LoadError
+  #do nothing
+end
+
+if defined? Rails
+  require 'programmable_scaffold_rails/engine'
+end

data/lib/programmable_scaffold_rails/action_controller_extensions.rb

@@ -0,0 +1,72 @@
+require 'ostruct'
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'programmable_scaffold_rails/config'
+require 'programmable_scaffold_rails/action_controller_helpers'
+require 'programmable_scaffold_rails/scaffold/new'
+require 'programmable_scaffold_rails/scaffold/create'
+require 'programmable_scaffold_rails/scaffold/index'
+require 'programmable_scaffold_rails/scaffold/show'
+require 'programmable_scaffold_rails/scaffold/edit'
+require 'programmable_scaffold_rails/scaffold/update'
+require 'programmable_scaffold_rails/scaffold/destroy'
+
+module ProgrammableScaffoldRails
+
+  module ActionControllerExtensions
+
+    extend ActiveSupport::Concern
+
+    module InstanceHelpers
+
+      def programmable_scaffold_controller_helpers
+        @programmable_scaffold_controller_helpers ||= ::ProgrammableScaffoldRails::ActionControllerHelpers.new(self)
+      end
+
+    end
+
+    module ClassMethods
+
+      # This is the core method which generate the scaffold things.
+      # It's important to notice that it uses a constant because it behaves like
+      # a class, can be inherited, overridden in child classes but it's "frozen"
+      # for the class where it's defined.
+      def programmable_scaffold(options={})
+        options = ::ProgrammableScaffoldRails::BASE_OPTIONS.merge(options)
+        crud    = ::ProgrammableScaffoldRails::CRUD_METHODS
+
+        # Validate
+        if options.include?(:only) && options.include?(:except)
+          raise ":only and :except option must not be used toghether"
+        end
+
+        # Process
+        crud = options[:only]          if options.include?(:only)
+        crud = crud - options[:except] if options.include?(:except)
+
+        send( :include, ProgrammableScaffoldRails::ActionControllerExtensions::InstanceHelpers )
+
+        send( :include, ProgrammableScaffoldRails::Scaffold::New     ) if crud.include?(:new)
+        send( :include, ProgrammableScaffoldRails::Scaffold::Create  ) if crud.include?(:create)
+        send( :include, ProgrammableScaffoldRails::Scaffold::Index   ) if crud.include?(:index)
+        send( :include, ProgrammableScaffoldRails::Scaffold::Show    ) if crud.include?(:show)
+        send( :include, ProgrammableScaffoldRails::Scaffold::Edit    ) if crud.include?(:edit)
+        send( :include, ProgrammableScaffoldRails::Scaffold::Update  ) if crud.include?(:update)
+        send( :include, ProgrammableScaffoldRails::Scaffold::Destroy ) if crud.include?(:destroy)
+
+        # Store
+        const_set(:PROGRAMMABLE_SCAFFOLD, OpenStruct.new(options).freeze)
+
+        self
+      end
+
+      def programmable_scaffold_options
+        const_get(:PROGRAMMABLE_SCAFFOLD)
+      end
+
+    end
+
+  end
+
+end

data/lib/programmable_scaffold_rails/action_controller_helpers.rb

@@ -0,0 +1,163 @@
+require 'active_support'
+require 'active_support/core_ext'
+
+module ProgrammableScaffoldRails
+
+  # Used to avoid polluting controller class with methods
+  class ActionControllerHelpers
+
+    def initialize(parent)
+      @parent = parent
+    end
+
+    def klass
+      return @klass if @klass
+
+      @klass = options[:class_name].try(:to_s) || controller.controller_name.to_s
+      @klass = @klass.classify.constantize
+    end
+
+    def table
+      return @table if @table
+
+      @table = options[:table_name].try(:to_s) || klass.to_s
+      @table = @table.tableize.to_sym
+    end
+
+    def cancan
+      return @cancan unless @cancan.nil?
+
+      @cancan = !!options[:cancan]
+    end
+
+    def single_instance_name
+      return @single_instance_name if @single_instance_name
+
+      @single_instance_name = options[:single_instance_name].try(:to_s) || table.to_s
+      @single_instance_name = @single_instance_name.singularize.to_sym
+    end
+
+    def single_instance
+      @single_instance ||= "@#{ single_instance_name }".to_sym
+    end
+
+    def multiple_instances_name
+      return @multiple_instances_name if @multiple_instances_name
+
+      @multiple_instances_name = options[:multiple_instances_name].try(:to_s) || table.to_s
+      @multiple_instances_name = @multiple_instances_name.pluralize.to_sym
+    end
+
+    def multiple_instances
+      @multiple_instances ||= "@#{ multiple_instances_name }".to_sym
+    end
+
+    def url_namespace
+      return @url_namespace if @url_namespace
+
+      @url_namespace = options[:url_namespace].try(:to_s) || ''
+    end
+
+    def after_create_action
+      @after_create_action = options[:after_create_action].try(:to_sym)
+    end
+
+    def after_update_action
+      @after_update_action = options[:after_update_action].try(:to_sym)
+    end
+
+    def formats
+      @formats ||= options[:formats]
+    end
+
+    def friendly_id
+      return @friendly_id unless @friendly_id.nil?
+
+      @friendly_id = !!options[:friendly_id]
+    end
+
+    def find_by_id_or_friendly_id(params)
+      found = nil
+      if friendly_id && klass.respond_to?(:friendly)
+        found = klass.friendly.find(params[:id])
+      else
+        found = klass.find(params[:id])
+      end
+
+      found
+    end
+
+    def strong_params
+      @strong_params ||= options[:strong_params].try(:to_sym)
+    end
+
+    def call_strong_params
+      unless controller.respond_to?(strong_params)
+        raise NotImplementedError, 'No strong_params method specified'
+      end
+      controller.send(strong_params)
+    end
+
+    def after_create_url(obj)
+      run_after_url_call_or_yield(:create, obj) { after_create_or_update_default_url(:create, obj) }
+    end
+
+    def after_update_url(obj)
+      run_after_url_call_or_yield(:update, obj) { after_create_or_update_default_url(:create, obj) }
+    end
+
+    def after_destroy_url(obj)
+      run_after_url_call_or_yield(:destroy, obj) do
+        if url_namespace.blank?
+          controller.url_for(multiple_instances_name)
+        else
+          controller.url_for([url_namespace, multiple_instances_name])
+        end
+      end
+    end
+
+    protected
+
+      def after_create_or_update_default_url(crud_action, obj)
+        after_action = send(:"after_#{ crud_action }_action")
+        if url_namespace.blank?
+          if after_action.nil? || after_action == :show
+            controller.url_for(obj)
+          else # :edit
+            controller.url_for([:edit, obj])
+          end
+        else
+          if after_action.nil? || after_action == :show
+            controller.url_for([url_namespace, obj])
+          else # :edit
+            controller.url_for([:edit, url_namespace, obj])
+          end
+        end
+      end
+
+      def controller
+        @parent
+      end
+
+    private
+
+      def options
+        @parent.class.programmable_scaffold_options
+      end
+
+      def run_after_url_call_or_yield(crud_action, obj)
+        after_url = options[:"after_#{ crud_action }_url"]
+        if after_url.class <= Symbol
+          controller.send(after_url, obj)
+        elsif after_url.class <= Proc
+          controller.instance_exec(obj, &after_url)
+        elsif after_url.class <= String
+          controller.url_for(after_url)
+        else
+          yield
+        end
+      end
+
+  end
+
+end