wrap_it 0.1.5 → 0.2.0

data/lib/wrap_it/container.rb

@@ -4,56 +4,97 @@ module WrapIt
   #
   # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
   #
+  # TODO: single_child
   class Container < Base
-    switch :deffered_render
+    switch :deffered_render do |_|
+      # avoid changing deffered_render after any child added
+      if @children.is_a?(Array)
+        @children.empty?
+      else
+        true
+      end
+    end
 
-    after_initialize do
-      @children = deffered_render? ? [] : empty_html
+    attr_reader :children
+    attr_writer :extract_children
+    section :children
+
+    def extract_children?
+      @extract_children == true
     end
 
-    def self.child(*args, &block)
-      create_args = args.last.is_a?(Array) ? args.pop : []
-      klass = args.pop
-      klass.is_a?(Class) && klass = klass.name
-      unless klass.is_a?(String)
-        args.push(klass)
-        klass = 'WrapIt::Base'
+    after_initialize do
+      @children = []
+      self.class.extract_from_options.each do |option, name|
+        args = options.delete(option)
+        next if args.nil?
+        args = [args] unless args.is_a?(Array)
+        self.deffered_render = true
+        send(name, *args)
       end
-      args.select! { |n| n.is_a?(Symbol) }
-      args.size > 0 || fail(ArgumentError, 'No valid method names given')
-      args.each do |method|
-        define_method method do |*helper_args, &helper_block|
-          # We should clone arguments becouse if we have loop in template,
-          # `extract_options!` below works only for first iterration
-          default_args = create_args.clone
-          options = helper_args.extract_options!
-          options[:helper_name] = method
-          options.merge!(default_args.extract_options!)
-          helper_args += default_args + [options]
-          add_children(klass, block, *helper_args, &helper_block)
+    end
+
+    #
+    # Defines child elements helper for creation of child items.
+    #
+    # @return [String]
+    def self.child(name, *args, &block)
+      name.is_a?(String) && name.to_sym
+      name.is_a?(Symbol) || fail(ArgumentError, 'Wrong child name')
+      child_class =
+        if args.first.is_a?(String) || args.first.is_a?(Class)
+          args.shift
+        else
+          'WrapIt::Base'
         end
+      child_class = child_class.name if child_class.is_a?(Class)
+      @helpers ||= []
+      @helpers << name
+      define_method name do |*helper_args, &helper_block|
+        # We should clone arguments becouse if we have loop in template,
+        # `extract_options!` below works only for first iterration
+        default_args = args.clone
+        options = helper_args.extract_options!
+        options[:helper_name] = name
+        options.merge!(default_args.extract_options!)
+        helper_args += default_args + [options]
+        add_children(name, child_class, block, *helper_args, &helper_block)
       end
     end
 
-#    protected
+    def self.extract_from_options(*args)
+      return @extract_from_options || [] if args.size == 0
+      hash = args.extract_options!
+      args.size.odd? && fail(ArgumentError, 'odd arguments number')
+      args.each_with_index { |arg, i| i.even? && hash[arg] = args[i + 1] }
+      @helpers ||= []
+      hash.symbolize_keys!
+      @extract_from_options = Hash[
+        hash.select do |k, v|
+          (v.is_a?(String) || v.is_a?(Symbol)) && @helpers.include?(k)
+        end.map { |k, v| [k, v.to_sym] }
+      ]
+    end
 
     after_capture do
       if deffered_render?
-        html = Hash[@children.map { |c| [c.object_id, capture { c.render }] }]
-        if omit_content?
-          @content = html.values.reduce(empty_html) { |a, e| a << e }
-        else
-          safe = html_safe?(@content)
-          @content = @content
+        html = Hash[children.map { |c| [c.object_id, capture { c.render }] }]
+        unless omit_content? || extract_children?
+          safe = html_safe?(self[:content])
+          self[:content] = self[:content]
             .split(CONTENT_SPLIT_REGEXP)
             .reduce(empty_html) do |a, e|
               match = CONTENT_REPLACE_REGEXP.match(e)
-              safe || e = html_safe(e)
-              a << match.nil? ? e : html[match[:obj_id].to_i(16)]
+              safe && e = html_safe(e)
+              str = match.nil? ? e : html.delete(match[:obj_id].to_i(16))
+              a << (str || empty_html)
             end
         end
-      else
-        omit_content? && @content = @children
+        # finally add all elements, not captured from markup
+        html.each do |id, str|
+          obj = ObjectSpace._id2ref(id)
+          obj.nil? || self[obj.render_to] << str
+        end
       end
     end
 
@@ -62,21 +103,33 @@ module WrapIt
     CONTENT_SPLIT_REGEXP = /(<!-- WrapIt::Container\(\h+\) -->)/
     CONTENT_REPLACE_REGEXP = /\A<!-- WrapIt::Container\((?<obj_id>\h+)\) -->\z/
 
-    def add_children(helper_class, class_block, *args, &helper_block)
+    def add_children(name, helper_class, class_block, *args, &helper_block)
+      options = args.extract_options!
+      section = options.delete(:section) || :children
+      args << options
       item = Object
         .const_get(helper_class)
         .new(@template, *args, &helper_block)
+      item.instance_variable_set(:@render_to, section)
+      item.instance_variable_set(:@parent, self)
+      item.define_singleton_method(:render_to) { @render_to }
+      item.define_singleton_method(:render_to=) do |value|
+        self.class.sections.include?(value) && @render_to = value
+      end
+      item.define_singleton_method(:parent) { @parent }
       class_block.nil? || instance_exec(item, &class_block)
 
-      item = item.render unless deffered_render?
-      @children << item if deffered_render? || omit_content?
-      if omit_content?
+      deffered_render? && @children << item
+      if !deffered_render? && (omit_content? || extract_children?)
+        self[section] << capture { item.render }
+      end
+      if omit_content? || extract_children?
         empty_html
       else
         if deffered_render?
           html_safe("<!-- WrapIt::Container(#{item.object_id.to_s(16)}) -->")
         else
-          item
+          item.render
         end
       end
     end

data/lib/wrap_it/enums.rb

@@ -61,7 +61,7 @@ module WrapIt
       # This method also adds getter and setter for this enum.
       #
       # @param  name [String, Symbol] Enum name. Converted to `Symbol`.
-      # @param  options = {} [Hash] Enum options
+      # @param  options [Hash] Enum options
       # @options options [String, Symbol] :html_class_prefix prefix of HTML
       #   class that will automatically added to element if enum changes its
       #   value.

data/lib/wrap_it/frameworks.rb

@@ -0,0 +1,24 @@
+#
+# Framework detection methods
+#
+module WrapIt
+  def self.framework
+    return @framework unless @framework.nil?
+    gems = Gem.loaded_specs.keys
+    if gems.include?('rails')
+      @framework = :rails
+    elsif gems.include?('sinatra')
+      @framework = :sinatra
+    else
+      @framework = :unknown
+    end
+  end
+
+  def self.rails?
+    framework == :rails
+  end
+
+  def self.sinatra?
+    framework == :sinatra
+  end
+end

data/lib/wrap_it/helpers.rb

@@ -0,0 +1,74 @@
+#
+# Helper registering
+#
+# @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+#
+module WrapIt
+  def self.register_module(*args)
+    options = args.extract_options!
+    options.symbolize_keys!
+    options = {prefix: ''}.merge(options)
+    mod = args.shift
+    mod.is_a?(Module) || mod = Module.new
+    mod.instance_eval do
+      define_singleton_method(:register, &WrapIt.register_block(options))
+      define_singleton_method(:unregister, &WrapIt.unregister_block(options))
+    end
+    mod
+  end
+
+  private
+
+  def self.register_block(options)
+    # Runs in helpers module class context
+    proc do |*args|
+      class_name = args.pop
+      class_name.is_a?(String) || class_name.is_a?(Class) || fail(
+        ArgumentError,
+        "Last argument for #{name}.register_helper should be a class name"
+      )
+      class_name.is_a?(Class) && class_name = class_name.name
+      helpers = instance_methods
+      args.each do |helper|
+        !helper.is_a?(Symbol) && fail(
+          ArgumentError,
+          "First arguments for WrapIt.register" \
+          " should be Symbols with helper names"
+        )
+        helpers.include?(helper) && fail(
+          ArgumentError, "Helper #{helper} for WrapIt.register allready exists"
+        )
+        define_method(
+          "#{options[:prefix]}#{helper}",
+          WrapIt.method_block(helper, class_name)
+        )
+      end
+    end
+  end
+
+  def self.unregister_block(options)
+    # Runs in helpers module class context
+    proc do |*list|
+      helpers = instance_methods
+      list.each do |helper|
+        helper.is_a?(String) && helper = helper.to_sym
+        next unless helper.is_a?(Symbol)
+        helper_name = "#{options[:prefix]}#{helper}"
+        next unless helpers.include?(helper_name)
+        remove_method helper_name
+      end
+    end
+  end
+
+  def self.method_block(name, class_name)
+    # Runs in helpers module context
+    proc do |*args, &block|
+      opts = args.extract_options!
+      opts[:helper_name] = name
+      args << opts
+      obj = Object.const_get(class_name).new(self, *args, &block)
+      obj.render
+    end
+  end
+end
+

data/lib/wrap_it/module_helpers.rb

@@ -0,0 +1,23 @@
+module WrapIt
+  module ModuleHelpers
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def placement(name)
+        define_method(
+          "#{name}_placement", &ModuleHelpers.placement_block(name)
+        )
+      end
+    end
+
+    private
+
+    def placement_block(name)
+      proc do |hash = {before: :content}|
+
+      end
+    end
+  end
+end

data/lib/wrap_it/sections.rb

@@ -0,0 +1,81 @@
+module WrapIt
+  #
+  # Adds sections functionality
+  #
+  # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+  #
+  module Sections
+    extend DerivedAttributes
+
+    def self.included(base)
+      base == Base || fail(
+        TypeError,
+        "#{self.class.name} can be included only into WrapIt::Base"
+      )
+      base.extend ClassMethods
+    end
+
+    def [](name)
+      @section_names ||= self.class.sections
+      return nil unless @section_names.include?(name)
+      @sections ||= {}
+      @sections[name] ||= empty_html
+    end
+
+    def []=(name, value)
+      @section_names ||= self.class.sections
+      return unless @section_names.include?(name)
+      @sections ||= {}
+      @sections[name] = value
+    end
+
+    #
+    # Class methods to include
+    #
+    module ClassMethods
+      def sections
+        collect_derived(:@sections)
+      end
+
+      def section(*args)
+        @sections ||= []
+        args.flatten.each do |name|
+          name.is_a?(String) && name = name.to_sym
+          next unless name.is_a?(Symbol)
+          next if (sections + [:begin, :end]).include?(name)
+          @sections << name
+          placement << name unless placement.include?(name)
+          place name, before: :end
+        end
+      end
+
+      def placement
+        @placement ||=
+          if self == Base
+            sections.clone
+          else
+            parent = ancestors[1..-1].find { |a| a.respond_to?(:placement) }
+            parent.nil? ? sections.clone : parent.placement.clone
+          end
+      end
+
+      def place(src, at, dst = nil)
+        if dst == nil && at.is_a?(Hash) && at.keys.size == 1
+          dst = at.values[0]
+          at = at.keys[0]
+        end
+        return unless placement.include?(src) &&
+          (dst == :begin || dst == :end || placement.include?(dst)) &&
+          (at == :before || at == :after)
+        item = placement.delete_at(placement.index(src))
+        case dst
+        when :begin then placement.unshift(item)
+        when :end then placement.push(item)
+        else
+          x = at == :before ? 0 : 1
+          placement.insert(placement.index(dst) + x, item)
+        end
+      end
+    end
+  end
+end

data/lib/wrap_it/switches.rb

@@ -21,7 +21,6 @@ module WrapIt
     def switches_init
       @switches = {}
       keys = switches.keys
-      # keys.each { |switch| @switches[switch] = false }
       @options.keys.select { |o| keys.include?(o) }.each do |switch|
         send("#{switches[switch][:name]}=", @options.delete(switch) == true)
       end
@@ -58,7 +57,7 @@ module WrapIt
       # on or removed in other case.
       #
       # @param  name [String, Symbol] Switch name. Converted to `Symbol`.
-      # @param  opts = {} [Hash] Switch options
+      # @param  opts [Hash] Switch options
       # @options opts [true, String, Symbol, Array<String, Symbol>] :html_class
       #   HTML classes list that will automatically added to element if switch
       #   is on or removed from element if switch id off.
@@ -66,7 +65,8 @@ module WrapIt
       #   Warning! Values are not converted - pass only `Symbols` here.
       # @yield [state] Runs block when switch state changed, gives it to block.
       # @yieldparam state [Boolean] Whether switch is on or off.
-      # @yieldreturn [void]
+      # @yieldreturn [Object, FalseClass] if you return `false`, value will
+      #   ommited.
       #
       # @return [void]
       def switch(name, options = {}, &block)
@@ -102,13 +102,14 @@ module WrapIt
     def self.setter(name, &block)
       proc do |value|
         opts = switches[name]
-        @switches[name] = value == true
-        if value == true
-          opts.key?(:html_class) && add_html_class(*opts[:html_class])
-          block.nil? || instance_exec(true, &block)
-        else
-          opts.key?(:html_class) && remove_html_class(*opts[:html_class])
-          block.nil? || instance_exec(false, &block)
+        cb_return = block.nil? || instance_exec(value == true, &block)
+        unless cb_return == false
+          @switches[name] = value == true
+          if value == true
+            opts.key?(:html_class) && add_html_class(*opts[:html_class])
+          else
+            opts.key?(:html_class) && remove_html_class(*opts[:html_class])
+          end
         end
       end
     end

data/lib/wrap_it/text_container.rb

@@ -9,6 +9,9 @@ module WrapIt
       base.class_eval do
         default_tag 'p', false
 
+        section :body
+        place :body, :before, :content
+
         after_initialize do
           @body = @arguments.extract_first!(String) || empty_html
           @body += @options[:body] || @options[:text] || empty_html
@@ -17,9 +20,11 @@ module WrapIt
         end
 
         after_capture do
-          @content = html_safe(@body) + @content unless @body.nil?
+          self[:body] = html_safe(@body) unless @body.nil?
         end
       end
     end
+
+    attr_accessor :body
   end
 end

data/lib/wrap_it/version.rb

@@ -1,4 +1,4 @@
 #
 module WrapIt
-  VERSION = '0.1.5'
+  VERSION = '0.2.0'
 end

data/lib/wrap_it.rb

@@ -1,76 +1,22 @@
-require 'wrap_it/no_rails' unless defined? Rails
+require 'wrap_it/frameworks'
 
-#
-# Main routines
-#
-# @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
-#
-module WrapIt
-  #
-  module Helpers; end
-
-  def self.helpers(*list)
-    @helpers ||= {}
-    options = list.extract_options!
-    list.empty? && list = @helpers.keys
-    prefix = options[:prefix].blank? ? '' : "#{options[:prefix]}_"
-    helpers_hash = @helpers
-    Helpers.module_eval do
-      list.each do |helper|
-        define_method "#{prefix}#{helper}" do |*args, &block|
-          opts = args.extract_options!
-          opts[:helper_name] = helper
-          args.push opts
-          obj = Object.const_get(helpers_hash[helper]).new(self, *args, &block)
-          obj.render
-        end
-      end
-    end
-    Helpers
-  end
-
-  def self.register(*args)
-    class_name = args.pop
-    !class_name.is_a?(String) && fail(
-      ArgumentError,
-      "Last argument for #{name}.register_helper should be a class name"
-    )
-    @helpers ||= {}
-    args.each do |arg|
-      !arg.is_a?(Symbol) && fail(
-        ArgumentError,
-        "First arguments for #{name}.register_helper" \
-        " should be Symbols with helper names"
-      )
-      @helpers.key?(arg) && fail(
-        ArgumentError,
-        "Helper #{arg} for #{name}.register_helper allready exists"
-      )
-      @helpers[arg] = class_name
-    end
-  end
-
-  def self.unregister(*helpers)
-    @helpers ||= {}
-    helpers.each do |helper|
-      helper.is_a?(String) && helper = helper.to_sym
-      next unless helper.is_a? Symbol
-      @helpers.delete(helper)
-    end
-  end
+if WrapIt.rails?
+  require 'rails'
+  require 'wrap_it/rails'
+else
+  require 'wrap_it/no_rails'
 end
 
+require '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'
-if defined? Rails
-  require 'wrap_it/rails'
-else
-end
 require 'wrap_it/base'
 require 'wrap_it/container'
 require 'wrap_it/text_container'