wrap_it 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 505e7bd562594a96b7765484ddd4332d6d6142e4
-  data.tar.gz: 82ff97e143fb9867e5cc0c3bb743ae28eb34bab3
+  metadata.gz: 995784a5858c83bfefb7ec041d0019e87535b279
+  data.tar.gz: 0e68c3329c7e692bbc685c09caf13981b7dcaa2a
 SHA512:
-  metadata.gz: bad8623fbebe0f97ab7ca7045f9c3a167254af82240147e282ee7d7d599925106bd1ec3d21ffe0418d2defb9d1987f3a890a986575e6d12070caebbef9a02624
-  data.tar.gz: 8c25e53fca0f92d4ba82e2c05d32b1be2d48e869ea21f03beb8759a78aeedd1f9b72553031f4800b4ee8dc38e5c0ba5337875d0b9c602e2c404d70158ba46731
+  metadata.gz: 7fb4f2c24ce43bcdbb875dbc303aaa5562a0eb25d91aec437b6b30d254a1e2a3c6a9a22d8de9c00704048317b5aaf18ce19cfe00bb69765fd9735ddfb6801801
+  data.tar.gz: 0b026802d29c1c858e92d6de642b823a113b75fffef8a2c5420cd2b449137289c455d74eb87a7d2380ab86123dcf6a48ee7a16de6e9a6bbdd490638c55cd3f57

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p353

data/.yardopts

@@ -0,0 +1,3 @@
+--no-private
+--markup markdown
+--embed-mixins

data/README.md

@@ -1,19 +1,28 @@
+[![Gem Version](https://badge.fury.io/rb/wrap_it.png)](http://badge.fury.io/rb/wrap_it)
+[![Code Climate](https://codeclimate.com/github/cybernetlab/wrap_it.png)](https://codeclimate.com/github/cybernetlab/wrap_it)
+
 # WrapIt
 
 This library provides set of classes and modules with simple DSL for quick and easy creating html helpers with your own DSL. It's usefull for implementing CSS frameworks, or making your own.
 
+> Required ruby version is 2.0.0
+
+> **Warning** A lot of code refactored. API changed. Review you code if you using previous versions of library.
+
 For example, your designer makes perfect button style for some site. This element will appears in many places of site in some variations. The button have `danger`, `success` and `default` look, and can have `active` state. Button can have some icon. So, you make some CSS styles, and now you should place HTML markup of this element in many places of site. With `wrap_it` library you can do it with following code:
 
 ```ruby
+module Helpers; end
+
 WrapIt.register_module Helpers
 
 module Helpers
   class PerfectButton < WrapIt::Container
     include TextContainer
     html_class 'button'
-    enum :look, [:default, :success, :danger], html_class_prefix: 'button-'
+    enum :look, %i(default success danger), html_class_prefix: 'button-'
     switch :active, html_class: 'button-active'
-    child :icon, [tag: 'img', class: 'button-icon']
+    child :icon, tag: 'img', class: 'button-icon'
   end
 
   register :p_button, 'PerfectButton'
@@ -55,11 +64,9 @@ This will produce following code:
 
 Note, that lines 2 and 3 produces same html markup.
 
-> **Wraning!** Module registration process changed since 0.2.0. So, if you migrate from 0.1.5, look above examples again and fix your startup code.
-
 # Status
 
-Project in pre-release state. First release version `1.0.0` planned to February of 2014.
+This is a first release version - `1.0.0`.
 
 # Installation
 
@@ -87,25 +94,29 @@ Library have no specific configuration.
 
 # Usage
 
+Now, package is well documented, so make sure to inspect [Reference documentation](http://rubydoc.info/github/cybernetlab/wrap_it/frames)
+
 > This library actively used in [BootstrapIt](https://github.com/cybernetlab/bootstrap_it) package, so explore this project, especially it's [lib/bootstrap_it/view_helpers](https://github.com/cybernetlab/bootstrap_it/tree/master/lib/bootstrap_it/view_helpers) folder for usage examples.
 
-All helpers classes derived from `WrapIt::Base` class, that provides allmost all functionality. For helpers, thats includes other helpers, use `WrapIt::Container` class. Where are some library-specific methods, defined directly in `WrapIt` module.
+All helpers classes derived from `WrapIt::Base` class, that provides allmost all functionality. For helpers, thats includes other helpers, use `WrapIt::Container` class.
 
 Simple example explained above. More complex usage is to provide some logic to initalization, capturing and rendering process. To do this, use `after` or `before` `initialize`, `capture` and `reder` callbacks respectively. Usually `after` callbacks used. `initialize` callbacks runs around arguments and optioins parsing, `capture` callbacks runs around capturing element sections and `render` callbacks runs around wrapping content into element tag.
 
+Also, please inspect arguments [module documentation](http://rubydoc.info/github/cybernetlab/wrap_it/WrapIt/Arguments) for details about creation arguments and options.
+
 Inside callbacks some usefull instance variables available.
 
-`@tag` contains tag name for element.
+`tag` contains tag name for element.
 
-`@options` contains creation options hash. This hash also contains `:class` key with current set of HTML classes. But its recommended to use class-aware methods to manipulate html classes (see below). **Warning!** You **MUST** remove from this hash all your class-specific user options, because this hash will be used as list of HTML attributes of element.
+`html_attr` contains HTML attributes hash.
 
-`@arguments` array available only in `after_initialize` callback and contains creation arguments. Its recommended to extract arguments, related to your class from this array if you plan to subclass your helper in future, so when subclasses `after_initialize` called these arguments will not available there.
+`html_data` contains HTML data hash.
 
-Inside `capture` callback you deals with sections. This mechanism described in [Sections explained](https://github.com/cybernetlab/wrap_it/blob/master/sections_explained.md) article.
+`html_class` contains array of HTML classes and provides array-like acces to its. See [class documentation](http://rubydoc.info/github/cybernetlab/wrap_it/WrapIt/HTMLClass) for details.
 
-`@rendered` string available in `render` callbacks and contains rendered content. You can change it to any value. If you want to include some html markup use `html_safe` method (see below) to prevent HTML escaping.
+Inside `capture` callback you deals with sections. This mechanism explained in [module documentation](http://rubydoc.info/github/cybernetlab/wrap_it/WrapIt/Sections).
 
-`@template` contains rendering template. Use this variable carefully, so if you call `@template.link_to` or something else Rails-related, your library will not be portable to other frameworks. So, if you use this gem in user-end application, or Rails-only library, you are free to use all of `@template` methods.
+`template` contains rendering template. Use this variable carefully, so if you call `template.link_to` or something else Rails-related, your library will not be portable to other frameworks. So, if you use this gem in user-end application, or Rails-only library, you are free to use all of `template` methods.
 
 *Examples*
 
@@ -113,7 +124,7 @@ Prevent user from changing element tag:
 
 ```ruby
 class Helper < WrapIt::Base
-  after_initialize { @tag = 'table' }
+  after_initialize { self.tag = 'table' }
 end
 ```
 
@@ -121,9 +132,8 @@ Including some simple HTML into content
 
 ```ruby
 class IconHelper < WrapIt::Base
-  after_initialize do
-    @icon = optioins.delete(:icon)
-  end
+  option :icon
+  attr_accessor :icon
 
   after_capture do
     unless @icon.nil?
@@ -214,6 +224,24 @@ Sets html class prefix. It can be `Symbol` or `String` and converted to `String`
 
 Once this method called from class, this class will ommit any text content, captured from template. For example, `<%= element do %><p>Any content</p><% end %>` normally will produce `<div><p>Any content</p></div>`. In some cases you whant to drop `<p>Any content</p>`, for exmaple, inside tables.
 
+#### argument(name, first_only: false, after_options: false, **opts, &block)
+
+Desclares argument for capturing on initialization process.
+
+Inside initialization process, all arguments (except options hash), passed to constructor will be inspected to satisfy conditions, specified in `:if` and `:and` options. If this happens, and block given, it evaluated in context of component instance. If no block given, setter with `name` will be attempted to set value. In any way if conditions satisfied, argument removed from future processing.
+
+If no conditions specified, the `name` of attribute taked as only condition.
+
+#### option(name, after: nil, **opts, &block)
+
+Desclares option for capturing on initialization process.
+
+Provides same manner as `argument` but for hash of options, passed to constructor. Specified conditions are applied to options keys, not to values.
+
+> Hint: you can specify argument and options with same name to call
+> same setter.
+
+
 #### switch(name, options = {}, &block)
 
 Adds `switch`. Switch is a boolean flag. When element created, creation arguments will be scanned for `Symbol`, that equals to `name`. If it founded, switch turned on. Also creation options inspected. If its contains `name: true` key-value pair, this pair removed from options and switch also turned on. `name` can be `Symbol` or `String` and it converted to `Symbol`.
@@ -246,7 +274,7 @@ Adds one ore more sections to element. Refer to [Sections explained](https://git
 
 #### place(src, dst)
 
-Places section `src` to destination, specified in `dst` hash. `dst` is a single key-value Hash. Key can be `:before` and `:after`. Value can be `:begin`, `:end` or any section name. Refer to [Sections explained](https://github.com/cybernetlab/wrap_it/blob/master/sections_explained.md) article for description.
+Places section `src` to destination, specified in `dst` hash. `dst` is a single key-value Hash. Key can be `:before` and `:after`. Value can be `:begin`, `:end` or any section name.
 
 #### sections
 
@@ -278,15 +306,11 @@ Returns array of html classes
 
 Sets html class(es) for element. Arguments can be `String`, `Symbol` or `Array` of it. All converted to plain array of `Symbols`. Duplicated classes removed.
 
-#### add_html_class(*args)
-
-Adds html class. For args see `#html_class=`
+#### html_class << *args
 
-#### remove_html_class(*args)
+You can add html classes as into array
 
-Removes html class. For args see `#html_class=`
-
-#### html_class?(*args, &block)
+#### html_class.include?(*args, &block)
 
 Determines whether element contains class, satisfied by conditions, specified in method arguments.
 
@@ -301,68 +325,45 @@ In second form all arguments are ignored and for each comparison given block cal
 ```ruby
 # with `Symbol` or `String` conditions
 element.html_class = [:a, :b, :c]
-element.html_class?(:a)       #=> true
-element.html_class?(:d)       #=> false
-element.html_class?(:a, 'b')  #=> true
-element.html_class?(:a, :d)   #=> false
+element.html_class.include?(:a)       #=> true
+element.html_class.include?(:d)       #=> false
+element.html_class.include?(:a, 'b')  #=> true
+element.html_class.include?(:a, :d)   #=> false
 
 # with `Regexp` conditions
 element.html_class = [:some, :test]
-element.html_class?(/some/)         #=> true
-element.html_class?(/some/, /bad/)  #=> false
-element.html_class?(/some/, :test)  #=> true
+element.html_class.include?(/some/)         #=> true
+element.html_class.include?(/some/, /bad/)  #=> false
+element.html_class.include?(/some/, :test)  #=> true
 
 # with `Array` conditions
 element.html_class = [:a, :b, :c]
-element.html_class?(%w(a d)) #=> true
-element.html_class?(%w(e d)) #=> false
+element.html_class.include?(%w(a d)) #=> true
+element.html_class.include?(%w(e d)) #=> false
 
 # with block
 element.html_class = [:a, :b, :c]
-element.html_class? { |x| x == 'a' } #=> true
+element.html_class.include? { |x| x == 'a' } #=> true
 ```
 
-#### no_html_class?(*args, &block)
-
-Determines whether element doesn't contains class, satisfied by conditions, specified in method arguments. See `html_class?`.
-
-#### set_html_data(name, value)
-
-Sets HTML data attribute named `name` to `value`.
-
-#### remove_html_data(name)
-
-Removes HTML data attribute named `name`.
-
-## WrapIt::Container
-
-This class used for elements, that can hold other elements.
-
-At first, note, that children can be created by two ways. First - inside template and second - from code. If child created from template, you have two choises again: first to keep child in place, where it defined in template, second - to cut it from there and place together with other childs. Two variables affects on this process: `ommit_content`, defined in `WrapIt::Base` and `extarct_children`. If `ommit_content` is `true`, all content will be dropped and children placed inside `children` section. If `extract_children` is true, children also placed into `children` section, but `content` is keeped.
 
-At second, you have two choises of moment, when children rendered. If `deffered_render` set to `false`, that is as default, all children will be rendered immideately after creation, so you can't change any of them later. If you plan to render your container after children, you chould set it to `true`, so childrens are collected in buffer and will be rendered with parent.
-
-All children, added to container injected with `render_to` and `parent` methods, that are gives you rendering section name and container itself.
-
-### DSL methods
-
-#### child(name, *args, &block)
-
-Creates your own DSL method to create child items. In arguments, you should specify name of method. Then you can specify class name or class itself for child. If ommited, `WrapIt::Base` will be used. All other arguments will be mixed with arguments, specified by user and passed to child constructor. **Warning!** Make shure, that your child arguments don't begins with `String` if you ommit class argument. As workaround, don't ommit class argument and specify it as 'WrapIt::Base'. At last, you can define block, that will be called after creating child, but before its rendering. This child passed as argument to block.
-
-You can render children to section, other than `:children`. To do this, specify `section` option with section name.
-
-Look into [lib/bootstrap_it/view_helpers](https://github.com/cybernetlab/bootstrap_it/tree/master/lib/bootstrap_it/view_helpers) folder for usage examples.
+Look to [Reference documentation](http://rubydoc.info/github/cybernetlab/wrap_it/frames) for other classes description.
 
 # Todo
 
 * Enlarge library functionality
-* Strong testing
 * Finish Sinatra integration
-* Rubydoc documentation
 
 # Changes
 
+`1.0.0`
+* first release version
+* a lot of code refactored
+* documentation allmost finished
+* well test coverage
+* API changed
+* added: arguments and options processing
+
 `0.2.0`
 * added: sections mechanism
 * many fixes

data/lib/wrap_it.rb

@@ -1,23 +1,23 @@
-require 'wrap_it/frameworks'
+require File.join %w(wrap_it frameworks)
 
 if WrapIt.rails?
   require 'rails'
-  require 'wrap_it/rails'
+  require File.join %w(wrap_it rails)
 else
-  require 'wrap_it/no_rails'
+  require File.join %w(wrap_it no_rails)
 end
 
-require 'wrap_it/helpers'
+require File.join %w(wrap_it helpers)
 
-require 'wrap_it/derived_attributes'
-require 'wrap_it/callbacks'
-require 'wrap_it/sections'
-require 'wrap_it/arguments_array'
-require 'wrap_it/html_class'
-require 'wrap_it/html_data'
-require 'wrap_it/switches'
-require 'wrap_it/enums'
-require 'wrap_it/base'
-require 'wrap_it/container'
-require 'wrap_it/text_container'
-require 'wrap_it/link'
+require File.join %w(wrap_it derived_attributes)
+require File.join %w(wrap_it callbacks)
+require File.join %w(wrap_it capture_array)
+require File.join %w(wrap_it arguments)
+require File.join %w(wrap_it sections)
+require File.join %w(wrap_it html)
+require File.join %w(wrap_it switches)
+require File.join %w(wrap_it enums)
+require File.join %w(wrap_it base)
+require File.join %w(wrap_it container)
+require File.join %w(wrap_it text_container)
+require File.join %w(wrap_it link)

data/lib/wrap_it/arguments.rb

@@ -0,0 +1,368 @@
+module WrapIt
+  #
+  # This module responisble to parse creation arguments in component
+  # initialization process.
+  #
+  # Respect to ruby language, any method can take variable number of
+  # arguments and a hash of options. Also you can pass a block to it. So,
+  # when your component subclassed from WrapIt::Base, user can create its
+  # instances via helpers. And when such component initialized you should
+  # be able to process all arguments, passed to helper or constructor. Finally
+  # all unprocessed options setted as component html attributes.
+  #
+  # Two API methods provided for this purposes - `argument` and `option`.
+  # Each of them declares conditions for capturing some arguments and options.
+  # Conditions applies to arguments itself or to options keys. CapturedArray
+  # Array extension is used to capture arguments, so refer to its documentation
+  # for conditions details.
+  #
+  # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+  #
+  module Arguments
+    # Documentation includes
+    # @!parse extend  Arguments::ClassMethods
+
+    # module implementation
+
+    extend DerivedAttributes
+
+    #
+    def self.included(base)
+      @base = base
+      base.extend ClassMethods
+    end
+
+    #
+    # {Arguments} Class methods to include
+    #
+    module ClassMethods
+      #
+      # Desclares argument for capturing on initialization process.
+      #
+      # Inside initialization process, all arguments (except options hash),
+      # passed to constructor will be inspected to satisfy conditions,
+      # specified in `:if` and `:and` options. If this happens, and block
+      # given, it evaluated in context of component instance. If no block
+      # given, setter with `name` will be attempted to set value. In any way
+      # if conditions satisfied, argument removed from future processing.
+      #
+      # If no conditions specified, the `name` of attribute taked as only
+      # condition.
+      #
+      # @example  without conditions - name is a condition
+      #   class Button < WrapIt::Base
+      #     argument(:disabled) { |name, value| puts 'DISABLED' }
+      #   end
+      #
+      #   Button.new(template, :disabled)   # => 'DISABLED'
+      #   Button.new(template, 'disabled')  # => nothing
+      #
+      # @example  with conditions and setter
+      #   class Button < WrapIt::Base
+      #     argument :disabled, if: /^disable(?:d)?$/
+      #
+      #     def disabled=(value)
+      #       puts 'DISABLED'
+      #     end
+      #   end
+      #
+      #   Button.new(template, :disabled)   # => 'DISABLED'
+      #   Button.new(template, 'disabled')  # => 'DISABLED'
+      #   Button.new(template, :disable)    # => 'DISABLED'
+      #   Button.new(template, 'some_text') # => nothing
+      #
+      # @overload argument(name, opts = {}, &block)
+      #   @param  name [Symbol] unique name, used to refer to this declaration
+      #   @param  opts [Hash]   options
+      #   @option opts [Object]  :if one or array of conditions that should be
+      #     satisfied to capture argument. See {CaptureArray} for details. If
+      #     array given, conditions will be or'ed.
+      #   @option opts [Object]  :and additional one or array of conditions,
+      #     that will be and'ed with :if conditions.
+      #   @option opts [Boolean] :first_only (false) stop processing on first
+      #     match
+      #   @option opts [Boolean] :after_options (false) process this argument
+      #     after options
+      #   @yield [name, value] yields every time argument captured. Evaluated
+      #     in instance context
+      #   @yieldparam name [Symbol] name of argument, specified in name param
+      #     above
+      #   @yieldparam value [Object] real argument value
+      #
+      # @return [void]
+      # @since  1.0.0
+      def argument(name, first_only: false, after_options: false,
+                   **opts, &block)
+        name.is_a?(String) && name = name.to_sym
+        fail ArgumentError, 'Wrong name' unless name.is_a?(Symbol)
+        arguments[name] = {
+          name: name,
+          conditions: Arguments.make_conditions(name, **opts),
+          block: block,
+          first_only: first_only == true,
+          after_options: after_options == true
+        }
+      end
+
+      #
+      # Desclares option for capturing on initialization process.
+      #
+      # Provides same manner as {#argument} but for hash of options, passed
+      # to constructor. Specified conditions are applied to options keys, not
+      # to values.
+      #
+      # > Hint: you can specify argument and options with same name to call
+      # > same setter.
+      #
+      # @example  shared setter
+      #   class Button < WrapIt::Base
+      #     REGEXP = /^disable(?:d)?$/
+      #
+      #     argument :disabled, if: REGEXP
+      #     option   :disabled, if: %i(disable disabled)
+      #
+      #     def disabled=(value)
+      #       if value == true || REGEXP =~ value.to_s
+      #         puts 'DISABLED'
+      #       end
+      #     end
+      #   end
+      #
+      #   Button.new(template, :disabled)       # => 'DISABLED'
+      #   Button.new(template, 'disabled')      # => 'DISABLED'
+      #   Button.new(template, :disable)        # => 'DISABLED'
+      #   Button.new(template, disabled: true)  # => 'DISABLED'
+      #   Button.new(template, disable: true)   # => 'DISABLED'
+      #   Button.new(template, disable: false)  # => nothing
+      #   Button.new(template, 'some_text')     # => nothing
+      #
+      # @overload option(name, opts = {}, &block)
+      #   @param  name [Symbol] unique name, used to refer to this declaration
+      #   @param  opts [Hash]   options
+      #   @option opts [Object]  :if see
+      #     {WrapIt::Arguments::ClassMethods#argument}
+      #   @option opts [Object]  :and see
+      #     {WrapIt::Arguments::ClassMethods#argument}
+      #   @yield [name, value] yields every time option captured. Evaluated
+      #     in instance context
+      #   @yieldparam name [Symbol] name of option, specified in name param
+      #     above
+      #   @yieldparam value [Object] real option value
+      #
+      # @return [void]
+      # @since  1.0.0
+      def option(name, after: nil, **opts, &block)
+        name.is_a?(String) && name = name.to_sym
+        fail ArgumentError, 'Wrong name' unless name.is_a?(Symbol)
+        @dependencies = !after.nil?
+        options[name] = {
+          name: name,
+          conditions: Arguments.make_conditions(name, **opts),
+          block: block
+        }
+      end
+
+
+      #
+      # Capture arguments for class and it's ancestors. All captured arguments
+      # and options will be extracted from original `args` argument.
+      #
+      # Actually you rare needs to call this method directly. For example
+      # you can call it in instance
+      # {Arguments#capture_arguments! capture_arguments!}
+      # override to capture arguments for some child components.
+      #
+      # @example capturing arguments for child component
+      #   class Button < WrapIt::Base
+      #     option(:color) { |name, value| puts "BUTTON COLOR IS: #{value}" }
+      #   end
+      #
+      #   class Toolbar < WrapIt::Base
+      #     protected
+      #     def capture_arguments!(args, &block)
+      #       @button = Button.new(Button.capture_arguments!(args))
+      #       super(args, &block) # ! don't forget to call parent method
+      #     end
+      #   end
+      #
+      #   Toolbar.new(template, color: :red)  # => 'BUTTON COLOR IS red'
+      #
+      # @overload capture_arguments!(args, opts = {}, &block)
+      #   @param  args [Array<Object>] arguments to process (include options)
+      #   @param  opts [Hash] options
+      #   @option opts [Boolean] :inherited (true) process ancestors
+      #   @option opts [Base] :instance (nil) if specified valid instance,
+      #     all {ClassMethods#argument} and {ClassMethods#option} blocks will
+      #     and setters will be called.
+      #   @param  &block [Proc] block, passed to constructor if present
+      #
+      # @return [Array<Object>] captured arguments
+      def capture_arguments!(args, inherited = true, instance = nil, &block)
+        opts = args.extract_options!
+        if inherited
+          ancestors.take_while { |a| a != Arguments.base }
+                   .reverse
+                   .unshift(Arguments.base)
+                   .map do |a|
+            next unless a.methods.include?(:extract_for_class)
+            a.extract_for_class(args, opts, instance, &block)
+          end
+          result_args = collect_derived(:@provided_arguments, {}, :merge)
+                        .values
+                        .flatten
+          result_opts = collect_derived(:@provided_options, {}, :merge)
+                        .values
+                        .reduce({}) { |a, e| a.merge!(e) }
+        else
+          extract_for_class(args, opts, instance, &block)
+          result_args = @provided_arguments.values.flatten
+          result_opts = @provided_options
+                        .values
+                        .reduce({}) { |a, e| a.merge!(e) }
+        end
+        opts.empty? || args << opts
+        result_opts.empty? || result_args << result_opts
+        result_args
+      end
+
+      protected
+
+      attr_reader :provided_options, :provided_arguments, :provided_block
+
+      def option_provided?(*list)
+        return false if provided_options.nil?
+        if list.empty?
+          return provided_options.empty?
+        else
+          return list.all? do |option|
+            provided_options.key?(option)
+          end
+        end
+      end
+
+      def argument_provided?(*list)
+        return false if provided_arguments.nil?
+        if list.empty?
+          return provided_arguments.empty?
+        else
+          return list.all? do |arg|
+            provided_arguments.key?(arg)
+          end
+        end
+      end
+
+      def block_provided?
+        provided_block.is_a?(Proc)
+      end
+
+      def options
+        @options ||= {}
+      end
+
+      def arguments
+        @arguments ||= {}
+      end
+
+      def extract_args(args, list, instance = nil)
+        args.respond_to?(:extract!) || args.extend(WrapIt::CaptureArray)
+        list.each do |arg|
+          processed =
+            if arg[:first_only]
+              [args.capture_first!(*arg[:conditions])].compact
+            else
+              args.capture!(*arg[:conditions])
+            end
+          (provided_arguments[arg[:name]] ||= []).concat(processed)
+          next if instance.nil?
+          processed.each do |v|
+            instance.instance_exec(arg[:name], v, arg[:block], &SETTER)
+          end
+        end
+      end
+
+      def extract_opts(opts, instance = nil)
+        keys = opts.keys.extend(WrapIt::CaptureArray)
+        options.each do |name, opt|
+          (provided_options[name] ||= {}).merge!(Hash[
+            keys.capture!(*opt[:conditions])
+              .map do |key|
+                value = opts.delete(key)
+                unless instance.nil?
+                  instance.instance_exec(key, value, opt[:block], &SETTER)
+                end
+                [key, value]
+              end
+          ])
+        end
+      end
+
+      def extract_for_class(args, opts, instance = nil, &block)
+        @provided_options = {}
+        @provided_arguments = {}
+        @provided_block = block
+
+        after, before = arguments.values.partition { |x| x[:after_options] }
+
+        extract_args(args, before, instance)
+        extract_opts(opts, instance)
+        extract_args(args, after, instance)
+
+        @provided_block = nil
+      end
+    end
+
+    protected
+
+    # @!visibility public
+    #
+    # Captures arguments
+    #
+    # In rare cases you can override this method to control directly arguments
+    # capturing process. Refer to
+    # {ClassMethods#capture_arguments! capture_arguments!} for examples.
+    #
+    # > Note that this method is `protected`, so override should be `protected`
+    # > too.
+    #
+    # @param  args [Array<Object>] arguments, passed to constructor
+    # @param  block [Proc] block, passed to constructor
+    #
+    # @return [Array<Object>] captured arguments
+    def capture_arguments!(args, &block)
+      self.class.capture_arguments!(args, true, self, &block)
+    end
+
+    private
+
+    #
+    # Evaluated in instance context by .extract_for_class
+    #
+    SETTER = ->(name, value, block) do
+      if block.nil?
+        setter = "#{name}=".to_sym
+        respond_to?(setter) && send(setter, value)
+      else
+        instance_exec(name, value, &block)
+      end
+    end
+
+    def self.normalize_conditions(cond)
+      if cond.is_a?(Array) &&
+         cond.any? { |x| !x.is_a?(Symbol) && !x.is_a?(String) }
+        cond
+      else
+        [cond]
+      end
+    end
+
+    def self.make_conditions(name, **opts)
+      cond = normalize_conditions(opts.key?(:if) ? opts[:if] : name)
+      opts.key?(:and) && cond << {and: normalize_conditions(opts[:and])}
+      cond
+    end
+
+    def self.base
+      @base
+    end
+  end
+end