magic-resource 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 88c7e7680c76cf4d34bb5b067c01a80d731fb55d
+  data.tar.gz: 211494d054116ea4373f63f49f31eeba5b20bcca
+SHA512:
+  metadata.gz: 0f22e8a2cc3675a69c97453792b260b5abd919878e3304e6b48b91535b87ed11a779c083e7ad762e0da1822184e141f8ffa8aac23a52d58875f2a09f467ce353
+  data.tar.gz: f2f8eafac949a968111a00cd084d198c307f82faae122bdc07d6339fa5e13afbf79eadc3b8373e6fbf1f01b219b34618c84b1b276b878c19e857580002286d2f

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Sergey Tokarenko
+
+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,475 @@
+MagicResource
+==============
+
+MagicResource is a Rails plugin which introduces the resource-based ideology for WEB applications development.
+
+## Getting Started
+
+Add to your Gemfile:
+
+```ruby
+  gem 'magic-resource', git: 'git@gitlab.anahoret.com:anadea/magic-resource.git', tag: 'v0.0.3'
+```
+
+Run the bundle command to install it.
+
+Run the generator:
+```console
+rails generate magic_resource:install
+```
+
+Include to controller, typically to ApplicationController:
+```ruby
+class ApplicationController < ActionController::Base
+  include MagicResource::Controller
+```
+
+## Resource abstraction
+It is a quite naturally when we affecting to something, we always affecting to specific object or to the scope of alike objects. Just like the calling the instance method or class method. Even when we want to do something like `turn off all electrical devices in the house`, it's better and more natural to trigger the `turn_off_the_devices` method on `House.belongs_to(me)` object, rather than to implement inplace logic which will find all the devices, and do something with them.
+
+Lets think like that when building the RoR application. Any time when the browser makes the request to the server, it affects the specific object, or to the scope of alike object. In RoR terms, each call to the server affects to specific Model instance, or to the scope of such Model.
+
+Each Model has `resource_name`, typically that is the model's class name, underscored and pluralized. For Property model that will be `:properties`.
+
+Then, lets add the `resource_context` when we affecting to the Model. It is just a Symbol identity. It should have just a logical sense, but not tied to any terms from the application like user roles, application areas, menu items etc.
+
+For example, lets say that `admin` users should have an access to all crud actions for the Property model, and `guest` users should have acccess to show and filterable index actions only. It's better to say that Property model can be affected under `:crud` and `:search` contexts, rather than `:admin` and `:guest` ones. Then, if `admin` role will be renamed to `superadmin`, if crud actions will be available for `manager` as well etc - `:crud` context name will not loose the sense, rather than `:admin` context.
+
+The affecting to the Model is always has some context, it can't be blank. Lets say that default context for any Model is `:crud`.
+
+Each resource context means the separated controller and the special folder for templates. To finish the picture, lets add the single localization file, then say:
+> Resource is the container-like abstraction, which includes the Model, the contexts to be applied when affecting the Model, the scope of one-per-context Controllers, the scope of templates to be rendered with the Model, and single localization file.
+
+## Sources structure
+### Controllers
+Controllers should be placed to `app/controllers/#{resource_name}/#{resource_context}_controller.rb` and named accordingly. For Property model and :crud context it should be placed to `app/controllers/properties/crud_controller.rb` and contains something like:
+```ruby
+module Properties
+    class CrudController < ApplicationController
+    end
+end
+```
+
+### Models
+Nothing specific, place and name them as always.
+
+### Views
+There are the general folder for resource templates, named `app/views/#{resource_name}/`. In the root of this folter should be placed the templates which you normally want to name `shared`. In folters like `app/views/#{resource_name}/#{resource_context}/` should be placed the context-specific templates.
+
+The typical scope of templates for Property model under :crud context should looks like:
+* app/views/properties/crud/edit.html.haml
+* app/views/properties/crud/index.html.haml
+* app/views/properties/crud/new.html.haml
+* app/views/properties/crud/show.html.haml
+* app/views/properties/_form_attrs.html.haml
+* app/views/properties/_list_item.html.haml
+* app/views/properties/_form_search_attrs.html.haml
+* app/views/properties/_view.html.haml
+
+### Locales
+The single locale file should be placed to `config/locales/en/#{resource_name}.yml`. For Property model it should be placed to `config/locales/en/properties.yml` and contains something like:
+```yml
+en:
+    properties:
+        button_edit: 'Edit Property'
+```
+
+## Magic
+When we speaking about the `magic`, we mean some smart and powerful instruments. Just like:
+```ruby
+    redirect_to user
+```
+
+But, uncontrolled usage of such things is not good:
+```ruby
+    redirect_to my_favorite_variable
+```
+Where we go? Lets guess that to `users#show` action, and we going to rename the action or controller - how we can find all places in the sources which redirects to `users#show` in this way?
+
+Lets define, that the `magic` is good when it:
+* invariantly predictable
+* searchable in the sources
+* can be banned partially or totally in whole project
+
+## General rules
+Lets separate the controller's action and templates to two group - collection and member, dependent when we working with the single Model instance of with Model's scope.
+
+### Set the resource object
+In `collection` controller actions call `resources=` method:
+```ruby
+def index
+    self.resources = Property.all
+end
+```
+
+In `member` controller actions call `resource=` method:
+```ruby
+def show
+    self.resource = Property.find(params[:id])
+end
+```
+
+Controller will set the resource context automatically by controller's class name.
+
+### Get the resource object
+In 'collection' controller actions and templates call 'resources' method:
+```ruby
+resources.size
+```
+
+In 'member' controller actions and templates call 'resource' method:
+```ruby
+resource.full_name
+```
+
+### Magic patterns
+
+The full pattern looks like `#{resource_name}::#{resource_context}#{separator}#{identifier}`. Dependent on the magic method, it changes the separator and identifier sense:
+```ruby
+# the way to controller's action
+r.path_to 'users::search#show'
+
+# the template path
+r.render 'users::search/view'
+
+# the translation key
+r.t 'users::search.button_search'
+```
+
+When the context name is skipped, it means the inheritance of current context for current object, or apllying the default context to other object:
+```ruby
+r.path_to 'users#show' # inherit the current context
+
+r(resource).path_to 'users#show' # the same as
+r(resource).path_to 'users::crud#show'
+```
+
+MagicResource will check is the object's type matching to specified resource name:
+```ruby
+r(Property).path_to 'users#show' # raise exception
+```
+
+For current object is possible to skip the resource name:
+```ruby
+r.path_to '#index'
+```
+
+For current object is possible to specify just identifier:
+```ruby
+r.path_to :show
+```
+
+### Access to the magic
+Typically you want to inherit the current resource object and resource_context for the magic. To do this, in controller or template call `r` method. You are able to use short patterns in magic calls, as well as combined and full patterns:
+```ruby
+r.path_to :show
+r.path_to 'properties#show'
+r.path_to '::search#show'
+r.path_to 'properties::search#show'
+```
+
+Sometimes, you want to make a magic with some `other object`. To do this, in controller or template call `r` method with object as parameter. Once the `other object` is specified, you are forced to use only full patterns in magic calls:
+```ruby
+r(resource.user).path_to 'users#show'
+r(resource.user).path_to 'users::search#show'
+```
+
+When you pass the current resource as parameter, it anyway means that the `other object` is specified - you loose the current context and must use the full patterns in magic calls:
+```ruby
+r(resource).path_to 'properties#show'
+r(resource).path_to 'properties::search#show'
+```
+
+When you don't have the specific object, pass the class as parameter. It again means the `other object` rules:
+```ruby
+r(User).path_to 'users#index'
+```
+
+You can pass the form object as parameter, in this case the object inside it will be a the `other object`:
+```haml
+= r.form_for :update do |f|
+  = f.simple_fields_for :user do |uf|
+    = r(ff).render 'users/form_attrs', f: ff
+```
+
+## Magic methods
+### r.context?
+Check is the resource context is in the args list:
+```ruby
+r.context?(:crud, :search) # true
+```
+
+### r.t
+The call looks like:
+```ruby
+r.t :button_edit
+r(user).t 'users::crud.button_edit', {interpolation_option: 'foo'}
+```
+
+It will search the translation in next order:
+* users.crud.button_edit
+* users.button_edit
+* resources.crud.button_edit
+* resources.button_edit
+
+The method will not accept dotted keys like `.my.dotted.key`. But why do you want it actually? '.my_dotted_key' has the same count of chars, and it's better to separate the locales section by white space rather than to produce the one more subtree for nothing.
+
+### r.render
+The call looks like:
+```ruby
+r.render :form_attrs, f: f
+r(user).render 'users::crud/form_attrs', f: f
+```
+
+It will search the template in next order:
+* users/crud/_form_attrs
+* users/_form_attrs
+* resources/crud/_form_attrs
+* resources/_form_attrs
+
+The method will apply the specified object and context as `current` inside the target template.
+
+The method will not accept the subfolder `/form/attrs` templates just like r.t method.
+
+The accepts the form object as second param, and passes it as `f` local parameter:
+```haml
+= r.form_for :update do |f|
+  = r.render :form_attrs, f
+```
+
+It's good to render the other resource template, rather than mass calling to it's attributes or magic methods:
+```haml
+that is bad:
+= r(resource.user).link_to 'users#show', resource.user.name
+= resource.user.role
+= resource.user.last_logged_in
+
+that is good:
+= r(resource.user).render 'users#view'
+
+and then in 'app/views/users/_view'
+= r.link_to :show, resource.name
+= resource.role
+= resource.last_logged_in
+```
+
+In general, when you see in your partial the massive definition of full magic pattern - it's time to move this part to other resource's partial.
+
+### r.render_collection
+The call looks like:
+```ruby
+r.render_collection :list_item
+r(users).render_collection 'users::crud/list_item'
+```
+
+Just calls r.render for collection items, with current context inheritance in first sample.
+
+### r.render_collection_build
+The call looks like:
+```ruby
+r.render_collection_build :new_form
+r(users).render_collection_build 'users::crud/new_form'
+```
+
+Calls the r.render for 'object.soft_build' object (look at `stokarenko/association-soft-build` gem), with current context inheritance in first sample.
+
+### r.path_to
+The call looks like:
+```ruby
+r.path_to :show
+r(user).path_to 'users::crud#show'
+```
+
+Returns the URL to specific controller/action.
+
+To pass the URL parameters call it in hashable way:
+```ruby
+r.path_to show: {foo: :bar}
+r(user).path_to 'users::crud#show' => {foo: :bar}
+```
+
+### r.redirect_to
+Can be used only in controller.
+
+The call looks like:
+```ruby
+r.redirect_to :show
+r(user).redirect_to 'users::crud#show'
+```
+
+Redirects to specific controller/action.
+
+To pass the URL parameters call it in hashable way:
+```ruby
+r.redirect_to show: {foo: :bar}
+r(user).redirect_to 'users::crud#show' => {foo: :bar}
+```
+
+### r.link_to
+The call looks like:
+```ruby
+r.link_to :edit
+r(user).link_to 'users::crud#edit', 'Special edit button'
+```
+
+The method will build the link html tag to specific controller/action.
+
+It will accept the URL parameters in hashable way, just like `r.path_to` do.
+
+It will automatically apply the HTTP verb for the link.
+
+It will use `:button_#{action}` as the label param by default, then...
+
+It will apply `r.t` method if the label param is a Symbol.
+
+It will use string label param for label as it is.
+
+It will automatically set `:confirm` param to `true` for `:destroy` actions, then
+
+It will set `:confirm` param to `:confirm_destroy` if it is true, then
+
+It will apply r.t method for confirmation message if `:confirm` param if is a Symbol.
+
+It will apply `:confirm` string param as confirmation message as it is.
+
+It will accept the block to be used as label parameter.
+
+### r.link_to_if
+The call looks like:
+```ruby
+r.link_to_if true, :edit
+r(user).link_to_if false, 'users::crud#edit'
+```
+
+Works just like regular `link_to_if` but uses r.link_to on success.
+
+It will accept the URL parameters in hashable way, just like `r.path_to` do.
+
+It will accept the block to be used as label parameter.
+
+### r.link_to_unless
+The call looks like:
+```ruby
+r.link_to_unless false, :edit
+r(user).link_to_unless true, 'users::crud#edit'
+```
+
+Works just like regular `link_to_unless` but uses r.link_to on success.
+
+It will accept the URL parameters in hashable way, just like `r.path_to` do.
+
+It will accept the block to be used as label parameter.
+
+### r.form_for
+The call looks like:
+```ruby
+r.form_for :update do |f|
+end
+
+r(user).form_for 'users::crud#update' do |f|
+end
+```
+
+Build the form to specific controller/action.
+
+It will accept the URL parameters in hashable way, just like `r.path_to` do.
+
+It automatically set the HTTP verb.
+
+It uses the default `:simple` form helper prefix, so the form will be built with `simple_form_for` helper.
+
+It takes the second param as the form helper prefix to be used.
+
+It supports Ransack, just pass Ransack::Search object as second param.
+
+It takes the logical `#save` action, which will be transformed to `#create` or `#update` actions dependent on the object's persistency status.
+
+### r.content_for
+This method is too much magical, and disabled by default. Activate it in configuration if you really need it.
+
+The usage looks like:
+```haml
+- r(resource.user).content_for 'users:header_class', 'strong'
+- r(resource.user).content_for 'users:header_prefix' do
+    some super prefix
+
+= r(resource.user).render 'users::crud/view'
+```
+
+Then, in `app/views/users/crud/_view` template:
+```haml
+.header{class: r.content(:header_class) || :default}
+    = r.content(:header_prefix)
+    the body
+```
+
+The same can be done by locals passing to render, but sometimes we need to forward such locals deeply and deeply to other render calls. Looks like `r.content_for` method is a better solution for that...
+
+## Configuration
+MagicResource generator will prepare the `config/initializers/magic-resource.rb` config file.
+Please take a look on it:
+```ruby
+MagicResource.setup do |config|
+  ## Uncoment the line to change the context to be used as default.
+  ## Default value is `:crud`.
+  # config.default_context = :manage
+
+  ## Uncoment the line to change default form helper prefix.
+  ## Default value is `:simple`.
+  # config.default_form_type = :default
+
+  ## Change the method to adjust the level or resource magic.
+  ## possible methods are `no_magic`, `try_magic?` and `full_magic!`
+  ## Thechnically such methods just setting all following parameters to
+  ## `:by_exception`, `:by_warning` and `false` respectively.
+  config.no_magic
+
+  ############################
+  #### For all next parameters
+  #### the correct values are: `[false, :by_exception, :by_warning]`.
+
+  ## Will require to specify the resource name in helper's pattern when resource is "other".
+  ## Can be useful for fast development or experiments. But typically it's better
+  ## to switch it off later and define the resource names everywhere,
+  ## because the magic becames to be not predictable and searchable.
+  # config.force_resource_name_definition = :by_exception
+
+  ## Will require the correct resource assignation in controller
+  ## Means the situation when inside Users::CrudController you trying to do
+  ## self.resource = Property.first
+  # config.assert_resource_name_in_controller = :by_exception
+
+  ## Will disable content_for helper.
+  ## It is too much magical...
+  ## But in some cases it is the better than other solutions.
+  ## Try to avoid it.
+  ## Activate it if you really need it.
+  # config.disable_content_for_helper = :by_exception
+
+end
+```
+
+## Changes
+### v0.0.3
+* Added the possibility to pass URL params to routable helpers.
+* Not ActiveModel-like classes can be a resource.
+* `r` method will extract the `object` and use it as resource when form object received.
+* `r.render` accepts the form object as second param, and passes it as `f` local parameter.
+* Added `r.link_to_unless` helper.
+* `r.link_to`-like helpers accept the block as label.
+* Added `r.redirect_to` controller helper.
+
+## TODO
+* Implement resourcable Coccon, and make it less painful.
+* Leave r object in controller as it was set there (?).
+* Apply the passing of translation interpolation params as Hash (?).
+* Separate the helpers for controller and view.
+* Resource controllers.
+* Automatic preload in controllers, bases on statistic of association calls in templates.
+* inverse_of as default in ActiveModel (?).
+* Resource tests (?).
+* ActiveRecord translations.
+* cancancan integration.
+* Single-file navigation for whole application (?).
+* Routes definition helper.
+* Implement resources default templates, and configuration to turn them off.

data/lib/generators/magic_resource/install_generator.rb

@@ -0,0 +1,17 @@
+module MagicResource
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc 'Copy MagicResource default files'
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_initializer
+        template 'magic-resource.rb', 'config/initializers/magic-resource.rb'
+      end
+
+      def copy_locales
+        directory 'config/locales'
+      end
+
+    end
+  end
+end

data/lib/generators/magic_resource/templates/config/locales/en/resources.yml

@@ -0,0 +1,11 @@
+en:
+  resources:
+    button_index: 'List'
+    button_show: 'Show'
+    button_new: 'New'
+    button_create: 'Create'
+    button_edit: 'Edit'
+    button_update: 'Update'
+    button_destroy: 'Destroy'
+
+    confirm_destroy: 'Are you sure?'

data/lib/generators/magic_resource/templates/magic-resource.rb

@@ -0,0 +1,38 @@
+MagicResource.setup do |config|
+  ## Uncoment the line to change the context to be used as default.
+  ## Default value is `:crud`.
+  # config.default_context = :manage
+
+  ## Uncoment the line to change default form helper prefix.
+  ## Default value is `:simple`.
+  # config.default_form_type = :default
+
+  ## Change the method to adjust the level or resource magic.
+  ## possible methods are `no_magic`, `try_magic?` and `full_magic!`
+  ## Thechnically such methods just setting all following parameters to
+  ## `:by_exception`, `:by_warning` and `false` respectively.
+  config.no_magic
+
+  ############################
+  #### For all next parameters
+  #### the correct values are: `<%= MagicResource::MAGIC_VALID_VALUES.inspect %>`.
+
+  ## Will require to specify the resource name in helper's pattern when resource is "other".
+  ## Can be useful for fast development or experiments. But typically it's better
+  ## to switch it off later and define the resource names everywhere,
+  ## because the magic becames to be not predictable and searchable.
+  # config.force_resource_name_definition = :by_exception
+
+  ## Will require the correct resource assignation in controller
+  ## Means the situation when inside Users::CrudController you trying to do
+  ## self.resource = Property.first
+  # config.assert_resource_name_in_controller = :by_exception
+
+  ## Will disable content_for helper.
+  ## It is too much magical...
+  ## But in some cases it is the better than other solutions.
+  ## Try to avoid it.
+  ## Activate it if you really need it.
+  # config.disable_content_for_helper = :by_exception
+
+end

data/lib/magic-resource.rb

@@ -0,0 +1,76 @@
+require 'magic-resource/version'
+
+require 'ruby-features'
+require 'activerecord-devkit'
+
+require 'magic-resource/railtie'
+
+module MagicResource
+  autoload :Controller,         'magic-resource/controller'
+  autoload :Helper,             'magic-resource/helper'
+  autoload :Container,          'magic-resource/container'
+  autoload :PathWithHttpVerb,   'magic-resource/path_with_http_verb'
+
+  module Generators
+    autoload :InstallGenerator, 'generators/magic_resource/install_generator'
+  end
+
+  MAGIC_PARAMETERS = %w(
+    force_resource_name_definition
+    assert_resource_name_in_controller
+    disable_content_for_helper
+  ).freeze
+  MAGIC_VALID_VALUES = [false, :by_exception, :by_warning].freeze
+
+  mattr_accessor :default_context
+  @@default_context = :crud
+
+  mattr_accessor :default_form_type
+  @@default_form_type = :simple
+
+  MAGIC_PARAMETERS.each do |param|
+    mattr_reader param.to_sym
+    class_variable_set(:"@@#{param}", :by_exception)
+
+    define_singleton_method(:"#{param}=") do |value|
+      raise ArgumentError.new(
+        "Unknown value: #{value.inspect}. Valid values are: #{MAGIC_VALID_VALUES.inspect}"
+      ) unless MAGIC_VALID_VALUES.include?(value)
+      class_variable_set(:"@@#{param}", value)
+    end
+  end
+
+  def self.setup
+    yield self
+  end
+
+  def self.no_magic
+    set_all_magic_parameters(:by_exception)
+  end
+
+  def self.try_magic?
+    set_all_magic_parameters(:by_warning)
+  end
+
+  def self.full_magic!
+    set_all_magic_parameters(false)
+  end
+
+  def self.set_all_magic_parameters(value)
+    MAGIC_PARAMETERS.each do |param|
+      public_send(:"#{param}=", value)
+    end
+  end
+
+  def self.logger
+    ::Rails.logger
+  end
+
+  def self.assert_restriction(restriction_type, message)
+    message.prepend('MagicResource: ')
+    case class_variable_get(:"@@#{restriction_type}")
+    when :by_exception then raise(message)
+    when :by_warning then logger.warn(message)
+    end
+  end
+end

data/lib/magic-resource/container.rb

@@ -0,0 +1,288 @@
+module MagicResource
+  class Container
+
+    CONTEXT_PATTERNS = {
+      route: '#',
+      translation: '.',
+      template: '/',
+      content: ':'
+    }.inject({}){ |mem, (type, separator)|
+      mem[type] = {
+        separator: separator,
+        regexp: /^(?<name>\w+)?#{'(?:::(?<context>\w+))?' unless type == :content}(?:#{Regexp.quote(separator)}(?<target>\w+#{'\??' if type == :translation}))$/
+      }; mem
+    }.freeze
+
+    attr_reader :name, :context, :collection, :item
+    alias resources collection
+    alias resource item
+
+    def context?(*args)
+      args.include?(context)
+    end
+
+    def render(partial, *args)
+      options = args.extract_options!
+      if args.present? && form = args.shift
+        raise 'Form object containing wrong resource' unless form.object == rs
+        options[:f] = form unless options.has_key?(:f)
+      end
+
+      partial, ct = extract_context(partial, :template)
+
+      lookup_templates = [name, :resources].
+        flat_map{|lc| ["#{lc}/#{ct}", lc] }.
+        map{|l| "#{l}/#{partial}"}
+
+      template = lookup_templates.find{|t| helper.lookup_context.template_exists?(t, [], true)}
+      raise("Can't find #{lookup_templates[0]} template for #{name} resource") unless template
+
+      with_context(ct){helper.with_resource_container(self){helper.render(template, options)}}
+    end
+
+    def render_collection(partial, options = {})
+      partial, ct = extract_context(partial, :template)
+      collection.map{|r| helper.r(r).render("#{name}::#{ct}/#{partial}", options)}.join.html_safe
+    end
+
+    def t(key, options = {})
+      key, ct = extract_context(key, :translation)
+
+      lookup_keys = [name, :resources].
+        flat_map{|lc| ["#{lc}.#{ct}", lc] }.
+        map{|l| :"#{l}.#{key}"}
+
+      helper.t(
+        lookup_keys[0],
+        options.merge(
+          default: lookup_keys[1..-1] + Array.wrap(options[:default])
+        )
+      )
+    end
+
+    def render_collection_build(partial, options = {})
+      partial, ct = extract_context(partial, :template)
+      helper.r(resources.soft_build).render("#{name}::#{ct}/#{partial}", options)
+    end
+
+    def link_to(action, *args, &block)
+      options = args.extract_options!
+
+      action, ct, route_args = extract_route_context(action)
+      with_context(ct) do
+        url, method = route_to(action, route_args)
+        link_options = {}
+
+        link_options[:method] = method unless method == :get
+
+        confirm = options.delete(:confirm){method === :delete}
+        confirm = :confirm_destroy if confirm === true
+        confirm = t(confirm) if confirm.kind_of?(Symbol)
+        link_options[:data] = {confirm: confirm} if confirm
+
+        label = label_for_link(action, args.first, &block)
+
+        helper.link_to(label, url, link_options.deep_merge(options))
+      end
+    end
+
+    #Used in controller and view
+    def path_to(action)
+      action, ct, route_args = extract_route_context(action)
+      with_context(ct) do
+        route_to(action, route_args).first
+      end
+    end
+
+    #Used in controller
+    def redirect_to(action, options = {})
+      helper.redirect_to path_to(action), options
+    end
+
+    def link_to_if(condition, action, *args, &block)
+      if condition
+        link_to(action, *args, &block)
+      else
+        action, ct = extract_route_context(action)
+        args.extract_options!
+        with_context(ct) do
+          label_for_link(action, args.first, &block)
+        end
+      end
+    end
+
+    def link_to_unless(condition, *args, &block)
+      link_to_if(!condition, *args, &block)
+    end
+
+    def form_for(action, *args, &block)
+      options = args.extract_options!
+      form_type = args.shift
+
+      action, ct, route_args = extract_route_context(action)
+      with_context(ct) do
+        url, method = route_to(action, route_args)
+
+        form_type ||= MagicResource.default_form_type
+        form_type, obj = form_type.kind_of?(Ransack::Search) ?
+          [:search, form_type] :
+          [form_type, item]
+        helper.public_send(:"#{form_type}_form_for", obj, {url: url, method: method}.merge(options), &block)
+      end
+    end
+
+    def content_for(index, *args, &block)
+      MagicResource.assert_restriction(
+        :disable_content_for_helper,
+        "#content_for helper is too much magical...: #{index}"
+      )
+
+      content = if block_given?
+        raise ArgumentError.new("Both content param and block specified: #{index}") if args.present?
+        helper.capture(&block)
+      else
+        raise ArgumentError.new("Need to specify the content by second param or block: #{index}") unless args.present?
+        args.first
+      end
+
+      index = extract_context(index, :content)
+
+      helper.resource_contents[rs] ||= {}
+      helper.resource_contents[rs][index] = content
+    end
+
+    def content(index)
+      MagicResource.assert_restriction(
+        :disable_content_for_helper,
+        "`#content helper is too much magical...: #{index}"
+      )
+
+      index = extract_context(index, :content)
+
+      helper.resource_contents[rs].try(:[], index)
+    end
+
+    def _launch(helper, changed = false)
+      self.helper = helper
+      self.changed = changed
+      self
+    end
+
+    def self._launch(helper, *args)
+      args.present? ?
+        self.new(args.first)._launch(helper, true) :
+        # Let's try to keep resource_container to be private..
+        helper.send(:resource_container)._launch(helper)
+    end
+
+    private
+
+    attr_accessor :helper, :changed
+    alias changed? changed
+    attr_reader :rs
+    attr_writer :name, :collection, :item
+
+    def initialize(rs, context = nil)
+      rs = rs.object if rs.respond_to?(:object)
+      self.rs, self.context = rs, context
+    end
+
+    def rs=(new_rs)
+      @rs, self.name = new_rs.kind_of?(Symbol) ?
+        [nil, new_rs] :
+        [new_rs, nil]
+
+      self.collection, self.item = rs.respond_to?(:to_ary) ?
+        [rs, nil] :
+        [nil, rs]
+
+      # Just `||=` not working due to private method
+      self.name = self.name || self.class.resource_name(rs)
+    end
+
+    def context=(new_context)
+      @context = new_context || MagicResource.default_context
+    end
+
+    def extract_context(pattern, context_type)
+      parse_params = CONTEXT_PATTERNS[context_type]
+
+      pattern = pattern.to_s
+      pattern.prepend(parse_params[:separator]) unless pattern.include?(parse_params[:separator])
+      pattern_parts = pattern.match(parse_params[:regexp])
+      raise("Wrong resource target pattern: #{pattern}") unless pattern_parts
+
+      target_name = pattern_parts[:name].try(:to_sym)
+      MagicResource.assert_restriction(
+        :force_resource_name_definition,
+        "Need to specify resource name when switching resource: #{pattern}"
+      ) if changed? && target_name.nil?
+
+      if target_name
+        raise("Wrong resource name, expected #{name.inspect} but got #{target_name.inspect}") unless name == target_name
+      end
+
+      #Damn, string keys...
+      pattern_parts.names.include?('context') ?
+        [pattern_parts[:target].to_sym, pattern_parts[:context].try(:to_sym) || context] :
+        pattern_parts[:target].to_sym
+    end
+
+    def extract_route_context(action)
+      action, route_args = action.kind_of?(Hash) ? action.first : [action, {}]
+
+      extract_context(action, :route) << route_args
+    end
+
+    def with_context(context)
+      same_context = self.context == context
+      old_context, self.context = self.context, context unless same_context
+
+      yield
+    ensure
+      self.context = old_context unless same_context
+    end
+
+    def self.resource_name(duck)
+      raise 'Undefined resource name' if duck.nil?
+      return duck if duck.kind_of?(Symbol)
+      return duck.to_sym if duck.kind_of?(String)
+      return duck.model_name.route_key.to_sym if duck.respond_to?(:model_name)
+      return resource_name(duck.klass) if duck.respond_to?(:klass)
+      return resource_name(duck.class) unless duck.kind_of?(Class)
+      duck.name.underscore.pluralize.to_sym
+    end
+
+    def route_to(action, route_args = {}, only_path = true)
+      action = (item.try(:persisted?) ? :update : :create) if action == :save
+
+      options = helper.url_options.deep_merge(
+        action: action,
+        only_path: only_path,
+        _recall: {
+          controller: [name, context].compact.join('/'),
+          # Need to confuse Rails..
+          action: 'hope_not_existing_action'
+        }
+      ).deep_merge(route_args)
+
+      resource.try(:persisted?) ?
+        options[:_recall][:id] = resource :
+        options[:_recall].delete(:id)
+
+      url = helper._routes.url_for(options)
+      [url, url.http_verb]
+    end
+
+    def label_for_link(action, label, &block)
+      if block_given?
+        raise 'Both label and block are specified for link_to' if label
+        return helper.capture(&block)
+      end
+
+      label ||= :"button_#{action}"
+      label = t(label) if label.kind_of?(Symbol)
+      label
+    end
+  end
+end

data/lib/magic-resource/controller.rb

@@ -0,0 +1,73 @@
+module MagicResource
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      helper MagicResource::Helper
+      helper_method :resource_container, :with_resource_container, :resource_contents
+
+      prepend_before_action :prepare_resource_controller
+
+      protected
+      attr_reader :resources, :resource
+
+      private
+      attr_accessor :resource_name, :resource_context, :resource_container
+    end
+
+    protected
+
+    def resources=(resources)
+      @resources, @resource = resources, nil
+      prepare_resource_container(resources)
+    end
+
+    def resource=(resource)
+      @resources, @resource = nil, resource
+      prepare_resource_container(resource)
+    end
+
+    def r(*args)
+      MagicResource::Container._launch(self, *args)
+    end
+
+    private
+
+    def prepare_resource_controller
+      resource_config = self.class.name.match(/^(?<name>\w+?)::(?<context>\w+)Controller$/)
+      raise "Wrong resource controller name: #{self.class.name}" unless resource_config
+
+      self.resource_name = resource_config[:name].underscore.to_sym
+      self.resource_context = resource_config[:context].underscore.to_sym
+
+      prepare_resource_container
+    end
+
+    def prepare_resource_container(rs = nil)
+      _prepare_resource_container(rs)
+
+      MagicResource.assert_restriction(
+        :assert_resource_name_in_controller,
+        "Wrong resource name in controller, expected #{resource_name.inspect} but got #{resource_container.name.inspect}"
+      ) unless resource_container.name == resource_name
+    end
+
+    def _prepare_resource_container(rs)
+      self.resource_container = MagicResource::Container.new(rs || resource_name, resource_context)
+    end
+
+    def with_resource_container(new_resource_container)
+      same_resource_container = resource_container == new_resource_container
+      old_resource_container, self.resource_container = resource_container, new_resource_container unless same_resource_container
+
+      yield
+    ensure
+      self.resource_container = old_resource_container unless same_resource_container
+    end
+
+    def resource_contents
+      @_resource_contents ||= {}
+    end
+
+  end
+end

data/lib/magic-resource/feature.rb

@@ -0,0 +1,33 @@
+RubyFeatures.define('magic_resource') do
+  dependency 'activerecord_devkit/association_soft_build'
+
+  apply_to 'ActionDispatch::Http::URL' do
+    applied do |variable|
+      class << self
+        alias_method_chain :url_for, :http_verb
+      end
+    end
+
+    class_methods do
+      def url_for_with_http_verb(options, *args)
+        path = url_for_without_http_verb(options, *args)
+        options[:path].kind_of?(MagicResource::PathWithHttpVerb) ?
+          MagicResource::PathWithHttpVerb.new(options[:path], path) :
+          path
+      end
+    end
+  end
+
+  apply_to 'ActionDispatch::Journey::Route' do
+    applied do
+      alias_method_chain :format, :http_verb
+    end
+
+    instance_methods do
+      def format_with_http_verb(*args)
+        MagicResource::PathWithHttpVerb.new(self.verb, format_without_http_verb(*args))
+      end
+    end
+  end
+
+end.apply

data/lib/magic-resource/helper.rb

@@ -0,0 +1,11 @@
+module MagicResource
+  module Helper
+
+    delegate :resource, :resources, to: :resource_container
+
+    def r(*args)
+      MagicResource::Container._launch(self, *args)
+    end
+
+  end
+end

data/lib/magic-resource/path_with_http_verb.rb

@@ -0,0 +1,13 @@
+module MagicResource
+  class PathWithHttpVerb < String
+    attr_reader :http_verb
+
+    def initialize(http_verb, path)
+      @http_verb = http_verb.kind_of?(self.class) ?
+        http_verb.http_verb :
+        http_verb.source.scan(/\w+/).first.try(:downcase).try(:to_sym)
+
+      super(path)
+    end
+  end
+end

data/lib/magic-resource/railtie.rb

@@ -0,0 +1 @@
+require 'magic-resource/feature'

data/lib/magic-resource/version.rb

@@ -0,0 +1,3 @@
+module MagicResource
+  VERSION = '0.0.4'.freeze
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: magic-resource
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Sergey Tokarenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: ruby-features
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+- !ruby/object:Gem::Dependency
+  name: activerecord-devkit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rails plugin which introduces the resource-based ideology for WEB applications
+  development.
+email: private.tokarenko.sergey@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/generators/magic_resource/install_generator.rb
+- lib/generators/magic_resource/templates/config/locales/en/resources.yml
+- lib/generators/magic_resource/templates/magic-resource.rb
+- lib/magic-resource.rb
+- lib/magic-resource/container.rb
+- lib/magic-resource/controller.rb
+- lib/magic-resource/feature.rb
+- lib/magic-resource/helper.rb
+- lib/magic-resource/path_with_http_verb.rb
+- lib/magic-resource/railtie.rb
+- lib/magic-resource/version.rb
+homepage: https://github.com/stokarenko/magic-resource
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Rails plugin which introduces the resource-based ideology for WEB applications
+  development.
+test_files: []
+has_rdoc: