wrap_it 0.1.0

data/spec/lib/arguments_array_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe WrapIt::ArgumentsArray do
+  it 'avoid of include these module into non-array like class' do
+    expect do
+      Class.new(String) { include WrapIt::ArgumentsArray }
+    end.to raise_error TypeError
+  end
+
+  context 'having test array' do
+    let :array do
+      arr = [10, :symbol, :another_symbol, 'string', 'another string']
+      arr.extend described_class
+    end
+
+    it 'extracts by class name' do
+      expect(array.extract!(Fixnum)).to eq [10]
+      expect(array).to_not include 10
+    end
+
+    it 'extracts by equality' do
+      expect(array.extract!(:symbol, 'string')).to eq [:symbol, 'string']
+      expect(array).to_not include :symbol, 'string'
+    end
+
+    it 'extracts by regexp' do
+      expect(
+        array.extract!(/\Aanother/)
+      ).to eq [:another_symbol, 'another string']
+      expect(array).to_not include :another_symbol, 'another string'
+    end
+
+    it 'extracts by array includance' do
+      expect(array.extract!([10, :symbol])).to eq [10, :symbol]
+      expect(array).to_not include 10, :symbol
+    end
+
+    it 'extracts by block' do
+      expect(array.extract! { |x| x == 10 }).to eq [10]
+      expect(array).to_not include 10
+    end
+
+    it 'extracts first by class name' do
+      expect(array.extract_first!(Symbol)).to eq :symbol
+      expect(array).to_not include :symbol
+    end
+
+    it 'extracts first by equality' do
+      expect(array.extract_first!(:symbol, 'string')).to eq :symbol
+      expect(array).to_not include :symbol
+    end
+
+    it 'extracts first by regexp' do
+      expect(array.extract_first!(/\Aanother/)).to eq :another_symbol
+      expect(array).to_not include :another_symbol
+    end
+
+    it 'extracts first by array includance' do
+      expect(array.extract_first!([10, :symbol])).to eq 10
+      expect(array).to_not include 10
+    end
+
+    it 'extracts first by block' do
+      expect(array.extract_first! { |x| x.is_a?(Symbol) }).to eq :symbol
+      expect(array).to_not include :symbol
+    end
+
+    it '#extract_first! returns nil if no matches' do
+      expect(array.extract_first!(20)).to be_nil
+      expect(array.size).to eq 5
+    end
+
+    it '#extract! returns [] if no matches' do
+      expect(array.extract!(20)).to eq []
+      expect(array.size).to eq 5
+    end
+
+    it 'works with and conditions' do
+      expect(array.extract!(Symbol, and: [:symbol])).to eq [:symbol]
+      expect(array).to_not include :symbol
+    end
+  end
+end

data/spec/lib/base_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe WrapIt::Base do
+  it 'have #tag getter' do
+    expect(successor.tag).to eq 'div'
+  end
+
+  it 'have default_tag class method' do
+    successor_class.class_eval { default_tag 'a' }
+    expect(successor.tag).to eq 'a'
+  end
+
+  it 'extends @arguments with ArgumentsArray module' do
+    expect(
+      successor.instance_variable_get(:@arguments)
+    ).to be_kind_of WrapIt::ArgumentsArray
+  end
+
+  it 'symbolizes options hash' do
+    successor.send :options=, 'my' => 'value'
+    expect(successor.options).to eq(my: 'value', class: [])
+  end
+
+  it 'sanitizes options class' do
+    successor.send :options=, class: [:one, :two, :two]
+    expect(successor.options[:class]).to eq %w(one two)
+  end
+
+  it 'calls after_initialize' do
+    successor_class.class_eval { after_initialize { add_html_class :a } }
+    expect(successor.html_class).to eq %w(a)
+  end
+
+  it 'not omits content by default' do
+    expect(successor.omit_content?).to be_false
+  end
+
+  it 'provides way to omit content in subclasses' do
+    successor_class.class_eval { omit_content }
+    expect(successor.omit_content?).to be_true
+  end
+
+  it 'removes `helper_name` from options' do
+    successor(helper_name: 'test')
+    expect(successor.options).to_not include :helper_name
+    expect(successor.instance_variable_get(:@helper_name)).to eq :test
+  end
+end

data/spec/lib/callbacks_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe WrapIt::Callbacks do
+  pending 'some tests here'
+end

data/spec/lib/container_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe WrapIt::Container do
+#  it 'adds base child' do
+#    successor_class.class_eval { child :test, [tag: 'li'] }
+#    successor.test
+#    expect(successor.instance_variable_get(:@children).size).to eq 1
+#  end
+end

data/spec/lib/derived_attributes_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe WrapIt::DerivedAttributes do
+  describe '::get_derived' do
+    it 'retrieves nil by default' do
+      expect(wrapper_class.get_derived(:@var)).to be_nil
+    end
+
+    it 'retrieves var, defined in class' do
+      wrapper_class.class_eval { @var = 1 }
+      sub1 = Class.new(wrapper_class) { @var = 2 }
+      sub2 = Class.new(sub1)
+      expect(wrapper_class.get_derived(:@var)).to eq 1
+      expect(sub1.get_derived(:@var)).to eq 2
+      expect(sub2.get_derived(:@var)).to eq 2
+    end
+  end
+
+  describe '::collect_derived' do
+    it 'collects in array by default' do
+      expect(wrapper_class.collect_derived(:@var)).to eq []
+    end
+
+    it 'collects vars in correct order' do
+      wrapper_class.class_eval { @var = '1' }
+      sub1 = Class.new(wrapper_class) { @var = '2' }
+      sub2 = Class.new(sub1)
+      expect(wrapper_class.collect_derived(:@var, [], :push)).to eq %w(1)
+      expect(sub1.collect_derived(:@var, [], :push)).to eq %w(2 1)
+      expect(sub2.collect_derived(:@var, [], :push)).to eq %w(2 1)
+    end
+
+    it 'collects arrays by default' do
+      wrapper_class.class_eval { @var = %w(1 2) }
+      sub1 = Class.new(wrapper_class) { @var = %w(2 3) }
+      expect(wrapper_class.collect_derived(:@var)).to eq %w(1 2)
+      expect(sub1.collect_derived(:@var)).to eq %w(2 3 1 2)
+    end
+
+    it 'collects hashes' do
+      wrapper_class.class_eval { @var = { one: 1, two: 2 } }
+      sub1 = Class.new(wrapper_class) { @var = { three: 3 } }
+      expect(
+        wrapper_class.collect_derived(:@var, {}, :merge)
+      ).to eq(one: 1, two: 2)
+      expect(
+        sub1.collect_derived(:@var, {}, :merge)
+      ).to eq(one: 1, two: 2, three: 3)
+    end
+  end
+end

data/spec/lib/enums_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe WrapIt::Enums do
+  context 'wrapper have `kind` enum' do
+    before { wrapper_class.class_eval { enum :kind, [:white, :black] } }
+
+    it 'adds getters' do
+      expect(wrapper.kind).to be_nil
+      wrapper.kind = true
+      expect(wrapper.kind).to be_nil
+      wrapper.kind = :white
+      expect(wrapper.kind).to eq :white
+    end
+
+    it 'gets enum value from arguments' do
+      expect(wrapper(:white).kind).to eq :white
+    end
+
+    it 'string arguments are ignored' do
+      expect(wrapper('white').kind).to be_nil
+    end
+
+    it 'gets enum from options' do
+      expect(wrapper(kind: :black).kind).to eq :black
+      @wrapper = nil
+      expect(wrapper(kind: false).kind).to be_nil
+      expect(wrapper.options).to_not include :kind
+    end
+
+    it 'runs block' do
+      wrapper_class.class_eval do
+        enum(:kind, [:white, :black]) { |x| self.html_class = x.to_s }
+      end
+      expect(wrapper(:white).html_class).to include 'white'
+      @wrapper = nil
+      expect(wrapper(kind: :black).html_class).to include 'black'
+      wrapper.kind = :white
+      expect(wrapper.html_class).to include 'white'
+    end
+
+    it 'adds and removes html class' do
+      wrapper_class.class_eval do
+        enum :kind, [:white, :black], html_class_prefix: 'test-'
+      end
+      expect(wrapper(:white).html_class).to include 'test-white'
+      @wrapper = nil
+      expect(wrapper(kind: :black).html_class).to include 'test-black'
+      @wrapper = nil
+      expect(wrapper(kind: :no).html_class).to be_empty
+      wrapper.kind = :white
+      expect(wrapper.html_class).to include 'test-white'
+      wrapper.kind = :black
+      expect(wrapper.html_class).to include 'test-black'
+      expect(wrapper.html_class).to_not include 'test-white'
+    end
+
+    it 'detects aliases' do
+      wrapper_class.class_eval do
+        enum :kind, [:white, :black], aliases: [:appearence]
+      end
+      expect(wrapper(appearence: :white).kind).to eq :white
+    end
+
+    it 'supports default values' do
+      wrapper_class.class_eval do
+        enum :kind, [:white, :black], default: :white
+      end
+      expect(wrapper.kind).to eq :white
+      wrapper.kind = :black
+      expect(wrapper.kind).to eq :black
+      wrapper.kind = nil
+      expect(wrapper.kind).to eq :white
+      @wrapper = nil
+      expect(wrapper(kind: :no).kind).to eq :white
+      @wrapper = nil
+      expect(wrapper(:black, kind: :no).kind).to eq :black
+    end
+  end
+end

data/spec/lib/html_class_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe WrapIt::HTMLClass do
+  it 'have html_class class method' do
+    wrapper_class.class_eval { html_class :a, [:b, 'c'] }
+    expect(wrapper.html_class).to eq %w(a b c)
+    sub_class = Class.new(wrapper_class) { html_class :a, [:d, 'e'] }
+    expect(sub_class.new(template).html_class).to eq %w(a d e b c)
+  end
+
+  it 'has #add_html_class with chaining' do
+    expect(wrapper.add_html_class(:test).options[:class]).to eq %w(test)
+    @wrapper = nil
+    expect(wrapper.add_html_class(:a, 'b').options[:class]).to eq %w(a b)
+    @wrapper = nil
+    expect(
+      wrapper.add_html_class(:a, [:b, :c]).options[:class]
+    ).to eq %w(a b c)
+  end
+
+  it 'has #remove_html_class with chaining' do
+    expect(
+      wrapper.add_html_class(:a, :b).remove_html_class('a').options[:class]
+    ).to eq %w(b)
+  end
+
+  it 'has #html_class? method' do
+    expect(wrapper.add_html_class(:a1, :b1).html_class?('a1')).to be_true
+    expect(wrapper.html_class?(:a1, :b1)).to be_true
+    expect(wrapper.html_class?(:a1, :b2)).to be_false
+    expect(wrapper.html_class?(:a2)).to be_false
+    expect(wrapper.html_class?(/\d+/)).to be_true
+    expect(wrapper.html_class?(%w(a1 c1))).to be_true
+    expect(wrapper.html_class? { |x| x[0] == 'a' }).to be_true
+  end
+
+  it 'has #html_class? method' do
+    expect(wrapper.add_html_class(:a1, :b1).no_html_class?('a2')).to be_true
+    expect(wrapper.no_html_class?(:a2, :b2)).to be_true
+    expect(wrapper.no_html_class?(:a1, :b2)).to be_false
+    expect(wrapper.no_html_class?(:a1)).to be_false
+    expect(wrapper.no_html_class?(/\d+./)).to be_true
+    expect(wrapper.no_html_class?(%w(c1 d1))).to be_true
+    expect(wrapper.no_html_class? { |x| x[0] == 'c' }).to be_true
+  end
+
+  it 'has html_class setter' do
+    wrapper.html_class = [:a, :b]
+    expect(wrapper.options[:class]).to eq %w(a b)
+  end
+
+  describe 'documentation examples' do
+    let(:element) { wrapper }
+
+    it 'html_class=' do
+      element.html_class = [:a, 'b', ['c', :d, 'a']]
+      expect(element.html_class).to eq %w(a b c d)
+    end
+
+    it 'add_html_class' do
+      element.html_class = 'a'
+      element.add_html_class :b, :c, ['d', :c, :e, 'a']
+      expect(element.html_class).to eq %w(a b c d e)
+    end
+
+    it 'remove_html_class' do
+      element.add_html_class %w(a b c d e)
+      element.remove_html_class :b, ['c', :e]
+      expect(element.html_class).to eq %w(a d)
+    end
+
+    it 'html_class? with Symbol or String' do
+      element.html_class = [:a, :b, :c]
+      expect(element.html_class?(:a)).to be_true
+      expect(element.html_class?(:d)).to be_false
+      expect(element.html_class?(:a, 'b')).to be_true
+      expect(element.html_class?(:a, :d)).to be_false
+    end
+
+    it 'html_class? with Regexp' do
+      element.html_class = [:some, :test]
+      expect(element.html_class?(/some/)).to be_true
+      expect(element.html_class?(/some/, /bad/)).to be_false
+      expect(element.html_class?(/some/, :test)).to be_true
+    end
+
+    it 'html_class? with Array' do
+      element.html_class = [:a, :b, :c]
+      expect(element.html_class?(%w(a d))).to be_true
+      expect(element.html_class?(%w(e d))).to be_false
+    end
+
+    it 'html_class? with block' do
+      element.html_class = [:a, :b, :c]
+      expect(element.html_class? { |x| x == 'a' }).to be_true
+    end
+  end
+end

data/spec/lib/switches_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe WrapIt::Switches do
+  context 'wrapper have `active` switch' do
+    before { wrapper_class.class_eval { switch :active } }
+
+    it 'adds getters' do
+      expect(wrapper.active?).to be_false
+      wrapper.active = true
+      expect(wrapper.active?).to be_true
+    end
+
+    it 'gets switch from arguments' do
+      expect(wrapper(:active).active?).to be_true
+    end
+
+    it 'string arguments are ignored' do
+      expect(wrapper('active').active?).to be_false
+    end
+
+    it 'gets switch from options' do
+      expect(wrapper(active: true).active?).to be_true
+      @wrapper = nil
+      expect(wrapper(active: false).active?).to be_false
+      expect(wrapper.options).to_not include :active
+    end
+
+    it 'runs block' do
+      wrapper_class.class_eval do
+        switch(:active) { |x| add_html_class(x.to_s) }
+      end
+      expect(wrapper(:active).html_class).to include 'true'
+      @wrapper = nil
+      expect(wrapper(active: true).html_class).to include 'true'
+      @wrapper = nil
+      expect(wrapper(active: false).html_class).to include 'false'
+      wrapper.active = true
+      expect(wrapper.html_class).to include 'true'
+      wrapper.active = false
+      expect(wrapper.html_class).to include 'false'
+    end
+
+    it 'adds and removes html class' do
+      wrapper_class.class_eval { switch :active, html_class: 'active' }
+      expect(wrapper(:active).html_class).to include 'active'
+      @wrapper = nil
+      expect(wrapper(active: true).html_class).to include 'active'
+      @wrapper = nil
+      expect(wrapper(active: false).html_class).to_not include 'active'
+      wrapper.active = true
+      expect(wrapper.html_class).to include 'active'
+      wrapper.active = false
+      expect(wrapper.html_class).to_not include 'active'
+    end
+
+    it 'detects aliases' do
+      wrapper_class.class_eval { switch :active, aliases: :act }
+      expect(wrapper(:act).active?).to be_true
+      @wrapper = nil
+      expect(wrapper(act: true).active?).to be_true
+      @wrapper = nil
+      expect(wrapper(act: false).active?).to be_false
+      expect(wrapper).to_not respond_to :act?
+    end
+  end
+end

data/spec/rails/base_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+=begin
+class UsersHelperTest < ActionView::TestCase
+  it 'includes framework-specific methods' do
+    methods = successor_class.protected_instance_methods(true)
+    expect(methods).to include :concat, :capture, :output_buffer
+  end
+
+  it 'renders base as div' do
+    render '<%= successor %>'
+    expect(rendered).to have_tag 'div', count: 1
+  end
+
+  it 'captures block content' do
+    render '<%= successor do %>Some text<% end %>'
+    expect(rendered).to have_tag 'div', count: 1, text: /Some text/
+  end
+end
+=end

data/spec/rails/container_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe WrapIt::Container do
+  before do
+    successor_class.class_eval do
+      default_tag 'ul'
+      child :item, [tag: 'li']
+    end
+    Object.send(:const_set, :Successor, successor_class)
+  end
+
+  it 'renders as ul' do
+    render '<%= successor_helper %>'
+    expect(rendered).to have_tag 'ul', count: 1
+    expect(rendered).to_not have_tag 'ul > *'
+  end
+
+  it 'renders child items' do
+    render <<-EOL
+      <%= successor_helper do |s| %>
+        <li class="c1">item 1</li>
+        <% 2.upto 5 do |i| %>
+        <%= s.item class: "c\#{i}" do |_| %>item <%= i %><% end %>
+        <% end %>
+        <li class="c6">item 6</li>
+      <% end %>
+    EOL
+    expect(rendered).to have_tag 'ul > li', count: 6
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default, :development
+
+Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

data/spec/support/example_groups/rails_example_group.rb

@@ -0,0 +1,79 @@
+#
+# Helpers for Rails-specific testing
+#
+# @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+#
+module RailsExampleGroup
+  def self.included(base)
+    base.instance_eval do
+      metadata[:type] = :rails
+
+      before(:all) { RailsExampleGroup.init_rails }
+      after(:all) do
+        Object.send(:remove_const, :Rails) if Object.const_defined?(:Rails)
+      end
+
+      after :each do
+        WrapIt.unregister :wrapper, :successor
+        Object.send(:remove_const, :Wrapper) if Object.const_defined?(:Wrapper)
+        if Object.const_defined?(:Successor)
+          Object.send(:remove_const, :Successor)
+        end
+      end
+
+      let(:template) do
+        instance_eval(&RailsExampleGroup.register_helper)
+        template_class.new.extend WrapIt.helpers
+      end
+
+      let(:template_class) { Class.new(ActionView::Base) }
+
+      let(:rendered) { @rendered }
+    end
+  end
+
+  def self.init_rails
+    require 'rails'
+    require 'active_support/dependencies'
+    require 'action_controller/railtie'
+    require 'action_view/railtie'
+    I18n.enforce_available_locales = true
+    path = File.expand_path(
+      File.join('..', '..', '..', '..', 'lib', 'wrap_it'),
+      __FILE__
+    )
+    WrapIt.send(:remove_const, :Renderer)
+    load File.join(path, 'rails.rb')
+    WrapIt::Base.send(:include, WrapIt::Renderer)
+  end
+
+  def self.register_helper
+    proc do
+      if described_class.is_a?(Class)
+        if Object.const_defined?(:Successor)
+          Object.send(:remove_const, :Successor)
+        end
+        Object.const_set(:Successor, successor_class)
+        WrapIt.unregister :successor_helper
+        WrapIt.register :successor_helper, 'Successor'
+      else
+        Object.sned(:remove_const, :Wrapper) if Object.const_defined?(:Wrapper)
+        Object.const_set(:Wrapper, wrapper_class)
+        WrapIt.unregister :wrapper_helper
+        WrapIt.register :wrapper_helper, 'Wrapper'
+      end
+    end
+  end
+
+  def render(code)
+    @rendered = template.render(inline: code)
+  end
+
+  RSpec.configure do |config|
+    config.include(
+      self,
+      type: :rails,
+      example_group: { file_path: /spec\/rails/ }
+    )
+  end
+end

data/spec/support/example_groups/wrap_it_example_group.rb

@@ -0,0 +1,39 @@
+#
+# Helpers for WrapIt testing
+#
+# @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+#
+module WrapItExampleGroup
+  def self.included(base)
+    base.instance_eval do
+      metadata[:type] = :wrap_it
+
+      after { @successor = nil }
+
+      let(:template) { Object.new }
+
+      let(:successor_class) { Class.new described_class }
+
+      let(:wrapper_class) do
+        mod = described_class
+        Class.new(WrapIt::Base) { include mod }
+      end
+    end
+  end
+
+  def successor(*args, &block)
+    @successor ||= successor_class.new(template, *args, &block)
+  end
+
+  def wrapper(*args, &block)
+    @wrapper ||= wrapper_class.new(template, *args, &block)
+  end
+
+  RSpec.configure do |config|
+    config.include(
+      self,
+      type: :wrap_it,
+      example_group: { file_path: /spec/ }
+    )
+  end
+end

data/wrap_it.gemspec

@@ -0,0 +1,30 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wrap_it/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'wrap_it'
+  spec.version       = WrapIt::VERSION
+  spec.authors       = ['Alexey Ovchinnikov']
+  spec.email         = ['alexiss@cybernetlab.ru']
+  spec.description   = %q{Set of classes and modules for creating HTML helpers}
+  spec.summary       = <<-EOL.gsub(/^\s+\|/, '')
+    |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.
+  EOL
+  spec.homepage      = 'https://github.com/cybernetlab/wrap_it'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'redcarpet', '~> 1.17'
+  spec.add_development_dependency 'yard', '~> 0.7.5'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-html-matchers'
+end