wrap_it 0.1.0

data/lib/wrap_it/container.rb

@@ -0,0 +1,84 @@
+module WrapIt
+  #
+  # Describes elements that can contain other elements
+  #
+  # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+  #
+  class Container < Base
+    switch :deffered_render
+
+    after_initialize do
+      @children = deffered_render? ? [] : empty_html
+    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'
+      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
+      end
+    end
+
+#    protected
+
+    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
+            .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)]
+            end
+        end
+      else
+        omit_content? && @content = @children
+      end
+    end
+
+    private
+
+    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)
+      item = Object
+        .const_get(helper_class)
+        .new(@template, *args, &helper_block)
+      class_block.nil? || instance_exec(item, &class_block)
+
+      item = item.render unless deffered_render?
+      @children << item if deffered_render? || omit_content?
+      if omit_content?
+        empty_html
+      else
+        if deffered_render?
+          html_safe("<!-- WrapIt::Container(#{item.object_id.to_s(16)}) -->")
+        else
+          item
+        end
+      end
+    end
+  end
+end

data/lib/wrap_it/derived_attributes.rb

@@ -0,0 +1,37 @@
+module WrapIt
+  #
+  # Adds minimal support to retrieve derived class variables
+  #
+  # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+  #
+  module DerivedAttributes
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    #
+    # Class methods to include
+    #
+    module ClassMethods
+      def get_derived(name)
+        return instance_variable_get(name) if instance_variable_defined?(name)
+        ancestors.each do |ancestor|
+          break if ancestor == Base
+          next unless ancestor.instance_variable_defined?(name)
+          return ancestor.instance_variable_get(name)
+        end
+        nil
+      end
+
+      def collect_derived(name, initial = [], method = :concat)
+        result = initial
+        ancestors.each do |ancestor|
+          break if ancestor == Base
+          next unless ancestor.instance_variable_defined?(name)
+          result = result.send(method, ancestor.instance_variable_get(name))
+        end
+        result
+      end
+    end
+  end
+end

data/lib/wrap_it/enums.rb

@@ -0,0 +1,89 @@
+module WrapIt
+  #
+  # Adds enums functionality
+  #
+  # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+  #
+  module Enums
+    def self.included(base)
+      base <= Base || fail(
+        TypeError,
+        "#{self.class.name} can be included only into WrapIt::Base subclasses"
+      )
+      extend DerivedAttributes
+      base.extend ClassMethods
+      base.after_initialize :enums_init
+    end
+
+    private
+
+    def enums_init
+      opt_keys = @options.keys
+      self.class.collect_derived(:@enums, {}, :merge).each do |name, opts|
+        value = nil
+        names = [name] + [opts[:aliases] || []].flatten
+        opt_keys.select { |o| names.include? o }.each do |key|
+          tmp = @options.delete(key)
+          value ||= tmp
+          !value.nil? && !opts[:values].include?(value) && value = nil
+        end
+        @arguments.extract!(Symbol, and: [opts[:values]]).each do |key|
+          value ||= key
+        end
+        send("#{name}=", value)
+      end
+    end
+
+    #
+    # Class methods to include
+    #
+    module ClassMethods
+      #
+      # @dsl
+      # Adds `enum`. When element created, creation arguments will be scanned
+      # for `Symbol`, that included contains in `values`. If it founded, enum
+      # takes this value. Also creation options inspected. If its  contains
+      # `name: value` key-value pair with valid value, this pair removed from
+      # options and enum takes this value.
+      #
+      # This method also adds getter and setter for this enum.
+      #
+      # @param  name [String, Symbol] Enum name. Converted to `Symbol`.
+      # @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.
+      # @options options [Symbol, Array<Symbol>] :aliases list of enum aliases.
+      #   Warning! Values are not converted - pass only `Symbols` here.
+      # @options options [String, Symbol] :default default value for enum,
+      #   if nil or wrong value given. Converted to `Symbol`.
+      # @yield [value] Runs block when enum value changed, gives it to block.
+      # @yieldparam value [Symbol] New enum value.
+      # @yieldreturn [void]
+      #
+      # @return [void]
+      def enum(name, values, options = {}, &block)
+        options.symbolize_keys!
+        name = name.to_sym
+        options.merge!(block: block, name: name, values: values)
+        options.key?(:default) && options[:default] = options[:default].to_sym
+        options.key?(:html_class_prefix) && options[:regexp] =
+          /\A#{options[:html_class_prefix]}(?:#{values.join('|')})\z/
+        var = "@#{name}".to_sym
+        define_method("#{name}") { instance_variable_get(var) }
+        define_method("#{name}=") do |value|
+          v = value if values.include?(value)
+          v ||= options[:default] if options.key?(:default)
+          instance_variable_set(var, v)
+          block.nil? || instance_exec(v, &block)
+          if options.key?(:regexp)
+            remove_html_class(options[:regexp])
+            v.nil? || add_html_class("#{options[:html_class_prefix]}#{v}")
+          end
+        end
+        @enums ||= {}
+        @enums[name] = options
+      end
+    end
+  end
+end

data/lib/wrap_it/html_class.rb

@@ -0,0 +1,193 @@
+module WrapIt
+  #
+  # Methods for manipulationg with HTML class. For internal usage.
+  # You should not include this class directly - subclass from
+  # `WrapIt::Base` instead.
+  #
+  # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+  #
+  module HTMLClass
+    extend DerivedAttributes
+
+    def self.included(base)
+      base <= Base || fail(
+        TypeError,
+        "#{self.class.name} can be included only into WrapIt::Base subclasses"
+      )
+      base.extend ClassMethods
+    end
+
+    #
+    # html class getter
+    #
+    # @return [Array<String>] array of html classes of element
+    def html_class
+      @options[:class]
+    end
+
+    #
+    # Sets html class(es) for element
+    # @param  value [Symbol, String, Array<Symbol, String>] HTML class or list
+    #   of classes. All classes will be converted to Strings, duplicates are
+    #   removed.
+    # @return [void]
+    #
+    # @example
+    #   element.html_class = [:a, 'b', ['c', :d, 'a']]
+    #   element.html_class #=> ['a', 'b', 'c', 'd']
+    def html_class=(value)
+      @options[:class] = []
+      add_html_class(value)
+    end
+
+    #
+    # Adds html class(es) to element. Chaining allowed. All classes will be
+    # converted to Strings, duplicates are removed.
+    # @override add_html_class([[html_class], ...])
+    # @param  html_class [Symbol, String, Array<Symbol, String>]
+    #   HTML class or list of HTML classes.
+    # @return [self]
+    #
+    # @example
+    #   element.html_class = 'a'
+    #   element.add_html_class :b, :c, ['d', :c, :e, 'a']
+    #   element.html_class #=> ['a', 'b', 'c', 'd', 'e']
+    def add_html_class(*args)
+      @options[:class] += args.flatten.map { |c| c.to_s }
+      @options[:class].uniq!
+      self # allow chaining
+    end
+
+    #
+    # Removes html class(es) from element. Chaining allowed
+    # @override add_html_class([[html_class], ...])
+    # @param html_class [Symbol, String, Regexp, Array<Symbol, String, Regexp>]
+    #   HTML class or list of HTML classes.
+    # @return [self]
+    #
+    # @example
+    #   element.add_html_class %w(a b c d e)
+    #   element.remove_html_class :b, ['c', :e]
+    #   element.html_class #=> ['a', 'd']
+    def remove_html_class(*args)
+      args.flatten!
+      re = []
+      args.reject! { |c| c.is_a?(Regexp) && re << c && true }
+      args = args.uniq.map { |c| c.to_s }
+      args.size > 0 && @options[:class].reject! { |c| args.include?(c) }
+      re.is_a?(Array) && re.each do |r|
+        @options[:class].reject! { |c| r.match(c) }
+      end
+      self # allow chaining
+    end
+
+    #
+    # Determines whether element contains class, satisfied by conditions,
+    # specified in method arguments.
+    #
+    # There are two forms of method call: with list of conditions as arguments
+    # and with block for comparing. Method makes comparison with html class
+    # untill first `true` return value or end of list. All conditions should
+    # be satisfied for `true` return of this method.
+    #
+    # In first form, each argument treated as condition. Condition can be a
+    # `Regexp`, so html classes of element tested for matching to that
+    # regular expression. If condition is an `Array` then every class will be
+    # tested for presence in this array. If condition is `Symbol` or `String`
+    # classes will be compared with it via equality operator `==`.
+    #
+    # In second form all arguments are ignored and for each comparison given
+    # block called with html class as argument. Block return value then used.
+    #
+    # @overload html_class([condition, ...])
+    # @param condition [<Regexp, Symbol, String, Array<String>]
+    #   condition for comparison.
+    #
+    # @overload html_class(&block)
+    # @yield [html_class] Gives each html class to block. You should return
+    #   `true` if element contains this html class.
+    # @yieldparam html_class [String] html class to inspect.
+    # @yieldreturn [Boolean] whether element has html class.
+    #
+    # @return [Boolean] whether element has class with specified conditions.
+    #
+    # @example 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
+    #
+    # @example 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
+    #
+    # @example with `Array` conditions
+    #   element.html_class = [:a, :b, :c]
+    #   element.html_class?(%w(a d)) #=> true
+    #   element.html_class?(%w(e d)) #=> false
+    #
+    # @example with block
+    #   element.html_class = [:a, :b, :c]
+    #   element.html_class? { |x| x == 'a' } #=> true
+    def html_class?(*args, &block)
+      args.all? { |c| inspect_class(:any?, c, &block) }
+    end
+
+    #
+    # Determines whether element doesn't contains class, satisfied by
+    # conditions, specified in method arguments.
+    #
+    # @see html_class?
+    def no_html_class?(*args, &block)
+      args.all? { |c| inspect_class(:none?, c, &block) }
+    end
+
+    protected
+
+    def add_default_classes
+      add_html_class self.class.collect_derived(:@html_class)
+    end
+
+    private
+
+    def inspect_class(with, value = nil, &block)
+      if block_given?
+        @options[:class].send(with, &block)
+      else
+        case
+        when value.is_a?(Regexp)
+          @options[:class].send(with) { |c| value.match(c) }
+        when value.is_a?(String) || value.is_a?(Symbol)
+          @options[:class].send(with) { |c| value.to_s == c }
+        when value.is_a?(Array)
+          @options[:class].send(with) { |c| value.include?(c) }
+        else
+          false
+        end
+      end
+    end
+
+    #
+    # Class methods to include
+    #
+    module ClassMethods
+      #
+      # @dsl
+      # Adds default html classes, thats are automatically added when element
+      # created.
+      # @override html_class([html_class, ...])
+      # @param  html_class [String, Symbol, Array<String, Symbol>] HTML class.
+      #   Converted to `String`
+      #
+      # @return [void]
+      def html_class(*args)
+        @html_class ||= []
+        @html_class += args.flatten.map { |c| c.to_s }
+        @html_class.uniq!
+      end
+    end
+  end
+end

data/lib/wrap_it/no_rails.rb

@@ -0,0 +1,66 @@
+
+methods = Hash.public_instance_methods(true)
+unless methods.include?(:extractable_options?)
+  Hash.send(:define_method, :extractable_options?, proc do
+    instance_of?(Hash)
+  end)
+end
+
+unless methods.include?(:symbolize_keys!)
+  Hash.send(:define_method, :symbolize_keys!, proc do
+    keys.each do |key|
+      next unless key.respond_to?(:to_sym)
+      self[key.to_sym] = delete(key)
+    end
+    self
+  end)
+end
+
+methods = Array.public_instance_methods(true)
+unless methods.include?(:extract_options!)
+  Array.send(:define_method, :extract_options!, proc do
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end)
+end
+
+module WrapIt
+  #
+  # Non rails render implementation
+  #
+  module Renderer
+    def empty_html
+      ''
+    end
+
+    def capture(text = nil)
+      block_given? ? yield : text
+    end
+
+    def concat(text)
+      @buffer ||= empty_html
+      @buffer << text
+    end
+
+    def output_buffer
+      @buffer
+    end
+
+    def content_tag(tag, body, options = {})
+      arr = [tag]
+      options.each { |o, v| arr << "#{o}=\"#{v.to_s}\"" }
+      "<#{arr.join(' ')}>#{body}</#{tag}>"
+    end
+
+    def html_safe(text)
+      text
+    end
+
+    def html_safe?(text)
+      true
+    end
+  end
+end

data/lib/wrap_it/rails.rb

@@ -0,0 +1,51 @@
+module WrapIt
+  #
+  # Provides render function for Rails
+  #
+  # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+  #
+  module Renderer
+    def empty_html
+      ''.html_safe
+    end
+
+    def html_safe(text)
+      text.html_safe
+    end
+
+    def html_safe?(text)
+      text.html_safe?
+    end
+
+    def superhtml(text)
+      text.to_s
+    end
+
+    def capture(*args, &block)
+      @template.capture(*args, &block)
+    end
+
+    def concat(*args, &block)
+      @template.concat(*args, &block)
+    end
+
+    def content_tag(*args, &block)
+      @template.content_tag(*args, &block)
+    end
+
+    def output_buffer(*args, &block)
+      @template.output_buffer(*args, &block)
+    end
+
+
+#    def self.included(base)
+#      puts "LOADED"
+#      base.class_eval do
+#        delegate :capture, :concat, :content_tag,
+#                 :output_buffer, to: :@template
+#        protected :capture, :concat, :content_tag,
+#                  :output_buffer
+#      end
+#    end
+  end
+end

data/lib/wrap_it/switches.rb

@@ -0,0 +1,82 @@
+module WrapIt
+  #
+  # Adds switches functionality
+  #
+  # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+  #
+  module Switches
+    def self.included(base)
+      base <= Base || fail(
+        TypeError,
+        "#{self.class.name} can be included only into WrapIt::Base subclasses"
+      )
+      extend DerivedAttributes
+      base.extend ClassMethods
+      base.after_initialize :switches_init
+    end
+
+    private
+
+    def switches_init
+      switches = self.class.collect_derived(:@switches, {}, :merge)
+      keys = switches.keys
+      keys.each { |switch| instance_variable_set("@#{switch}", false) }
+      @options.keys.select { |o| keys.include?(o) }.each do |switch|
+        send("#{switches[switch][:name]}=", @options.delete(switch) == true)
+      end
+      @arguments.extract!(Symbol, and: [keys]).each do |switch|
+        send("#{switches[switch][:name]}=", true)
+      end
+    end
+
+    #
+    # Class methods to include
+    #
+    module ClassMethods
+      #
+      # @dsl
+      # 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.
+      #
+      # This method also adds getter and setter for this switch in form `name?`
+      # and `name=` respectively.
+      #
+      # @param  name [String, Symbol] Switch name. Converted to `Symbol`.
+      # @param  options = {} [Hash] Switch options
+      # @options options [String, Symbol, Array<String, Symbol>] :html_class
+      #   HTML class that will automatically added to element if switch is on
+      #   or removed from element if switch id off.
+      # @options options [Symbol, Array<Symbol>] :aliases list of aliases.
+      #   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]
+      #
+      # @return [void]
+      def switch(name, options = {}, &block)
+        options.symbolize_keys!
+        name = name.to_sym
+        options.merge!(block: block, name: name)
+        names = [name] + [[options[:aliases]] || []].flatten
+        var = "@#{name}".to_sym
+        define_method("#{name}?") { instance_variable_get(var) == true }
+        define_method("#{name}=") do |value|
+          instance_variable_set(var, value == true)
+          if value == true
+            options.key?(:html_class) && add_html_class(options[:html_class])
+            block.nil? || instance_exec(true, &block)
+          else
+            options.key?(:html_class) &&
+              remove_html_class(options[:html_class])
+            block.nil? || instance_exec(false, &block)
+          end
+        end
+        @switches ||= {}
+        names.each { |n| @switches[n] = options }
+      end
+    end
+  end
+end

data/lib/wrap_it/text_container.rb

@@ -0,0 +1,25 @@
+module WrapIt
+  #
+  # TextContainer
+  #
+  # @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+  #
+  module TextContainer
+    def self.included(base)
+      base.class_eval do
+        default_tag 'p'
+
+        after_initialize do
+          @body = @arguments.extract_first!(String) || empty_html
+          @body += @options[:body] || @options[:text] || empty_html
+          @options.delete(:body)
+          @options.delete(:text)
+        end
+
+        after_capture do
+          @content = html_safe(@body) + @content unless @body.nil?
+        end
+      end
+    end
+  end
+end

data/lib/wrap_it/version.rb

@@ -0,0 +1,3 @@
+module WrapIt
+  VERSION = '0.1.0'
+end