wrap_it 0.2.0 → 1.0.0

data/spec/integration/base_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe WrapIt::Base do
+describe WrapIt::Base, type: :wrapped do
   it 'includes framework-specific methods' do
     methods = successor_class.protected_instance_methods(true)
     expect(methods).to include :concat, :capture, :output_buffer
@@ -58,7 +58,7 @@ describe WrapIt::Base do
     it 'wraps with block' do
       render <<-EOL
         <%= helper(tag: :p) { |s| s.wrap do
-          |w| w.add_html_class 'nav'
+          |w| w.html_class << 'nav'
         end } %>'
       EOL
       expect(rendered).to have_tag 'div.nav > p'

data/spec/integration/container_spec.rb

@@ -85,8 +85,8 @@ describe WrapIt::Container do
   end
 
   it 'extracts one child from optioins' do
-    successor_class.class_eval { extract_from_options :item, :item }
-    render '<%= helper item: {class: "list-item"} %>'
-    expect(rendered).to have_tag 'ul > li.list-item', count: 1
+    successor_class.class_eval { child :item1, tag: 'li', option: true }
+    render '<%= helper item1: {class: "listitem"} %>'
+    expect(rendered).to have_tag 'ul > li.listitem', count: 1
   end
 end

data/spec/integration/examples_spec.rb

@@ -8,25 +8,26 @@ describe WrapIt::Base do
           section :append, :prepend
           place :prepend, before: :content
           place :append, after: :content
-          after_initialize do
-            @prepend = options.delete(:prepend)
-            @append = options.delete(:append)
+
+          option :prepend do |_, value|
+            self[:prepend] = content_tag('span', value,
+                                         class: 'input-group-addon')
+          end
+
+          option :append do |_, value|
+            self[:append] = content_tag('span', value,
+                                        class: 'input-group-addon')
           end
+
           after_capture do
-            unless @prepend.nil?
-              self[:prepend] = content_tag('span', @prepend,
-                                           class: 'input-group-addon')
-            end
-            unless @append.nil?
-              self[:append] = content_tag('span', @append,
-                                          class: 'input-group-addon')
-            end
             if self[:content].empty?
-              options[:type] = 'text'
-              add_html_class 'form-control'
+              html_attr[:type] = 'text'
+              html_class << 'form-control'
+              options = html_attr
+                .merge(class: html_class.to_html)
+                .merge(html_data)
               self[:content] = content_tag('input', '', options)
-              options.clear
-              add_html_class 'input-group'
+              self.html_class = 'input-group'
             end
           end
         end

data/spec/integration/text_container_spec.rb

@@ -6,8 +6,8 @@ describe WrapIt::TextContainer do
     expect(rendered).to have_tag 'p', text: 'text'
   end
 
-  it 'places body from options prior to captured content' do
-    render '<%= helper "text" do %> with content<% end %>'
-    expect(rendered).to have_tag 'p', text: 'text with content'
+  it 'don\'t places body from options if content present' do
+    render '<%= helper "text" do %>with content<% end %>'
+    expect(rendered).to have_tag 'p', text: 'with content'
   end
 end

data/spec/lib/arguments_array_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe WrapIt::ArgumentsArray do
+describe WrapIt::CaptureArray do
   it 'avoid of include these module into non-array like class' do
     expect do
-      Class.new(String) { include WrapIt::ArgumentsArray }
+      Class.new(String) { include WrapIt::CaptureArray }
     end.to raise_error TypeError
   end
 
@@ -14,69 +14,79 @@ describe WrapIt::ArgumentsArray do
     end
 
     it 'extracts by class name' do
-      expect(array.extract!(Fixnum)).to eq [10]
+      expect(array.capture!(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']
+    it 'captures by equality' do
+      expect(array.capture!(:symbol, 'string')).to eq [:symbol, 'string']
       expect(array).to_not include :symbol, 'string'
     end
 
-    it 'extracts by regexp' do
+    it 'captures by regexp' do
       expect(
-        array.extract!(/\Aanother/)
+        array.capture!(/\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]
+    it 'captures by array includance' do
+      expect(array.capture!([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]
+    it 'captures by block' do
+      expect(array.capture! { |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
+    it 'captures first by class name' do
+      expect(array.capture_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
+    it 'captures first by equality' do
+      expect(array.capture_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
+    it 'captures first by regexp' do
+      expect(array.capture_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
+    it 'captures first by array includance' do
+      expect(array.capture_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
+    it 'captures first by block' do
+      expect(array.capture_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
+    it '#capture_first! returns nil if no matches' do
+      expect(array.capture_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 []
+    it '#capture! returns [] if no matches' do
+      expect(array.capture!(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]
+    it 'works fine with met `and` conditions' do
+      expect(array.capture!(Symbol, and: [:symbol])).to eq [:symbol]
+      expect(array).to_not include :symbol
+    end
+
+    it 'works fine with unmet `and` conditions ' do
+      expect(array.capture!(Symbol, and: [:sym])).to eq []
+      expect(array).to include :symbol
+    end
+
+    it 'calls lambdas before comparison' do
+      expect(array.capture!(-> {:symbol})).to eq [:symbol]
       expect(array).to_not include :symbol
     end
   end

data/spec/lib/arguments_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe WrapIt::Arguments, type: :wrapped do
+  # DSL
+  %i(argument option).each do |m|
+    describe ".#{m}" do
+      let(:params) { wrapper_class.instance_variable_get("@#{m}s") }
+
+      describe 'attribute parsing' do
+        it "rejects non-string name" do
+          expect { wrapper_class.send(m, 0) }.to raise_error ArgumentError
+        end
+
+        it 'symbolizes name' do
+          wrapper_class.send(m, 'name')
+          expect(params).to include :name
+        end
+
+        it 'makes conditions from name' do
+          wrapper_class.send(m, :name)
+          expect(params[:name][:conditions]).to eq [:name]
+        end
+
+        it 'wraps string-like conditions in array' do
+          wrapper_class.send(m, :name, if: [:one, 'two'])
+          expect(params[:name][:conditions]).to eq [[:one, 'two']]
+        end
+
+        it 'adds and option to conditions' do
+          wrapper_class.send(m, :name, if: 0, and: 1)
+          expect(params[:name][:conditions]).to eq [0, and: [1]]
+        end
+
+        it 'wraps string-like and in array' do
+          wrapper_class.send(m, :name, if: 0, and: [:one, 'two'])
+          expect(params[:name][:conditions]).to eq [0, and: [[:one, 'two']]]
+        end
+      end
+
+      if m == :argument
+        it 'permits :after_options' do
+          wrapper_class.argument :name, after_options: true
+          expect(params[:name][:after_options]).to be_true
+        end
+      end
+    end
+  end
+
+  describe '.extract_for_class' do
+    let(:args) { wrapper_class.send :provided_arguments }
+    let(:opts) { wrapper_class.send :provided_options }
+
+    it 'extracts arguments' do
+      wrapper_class.argument :name
+      a = [:name, :name, :test]
+      wrapper_class.send(:extract_for_class, a, {})
+      expect(args[:name]).to match_array [:name, :name]
+      expect(a).to match_array [:test]
+    end
+
+    it 'extracts options' do
+      wrapper_class.option :name
+      o = {name: :opt}
+      wrapper_class.send(:extract_for_class, [], o)
+      expect(opts[:name]).to eq(name: :opt)
+      expect(o).to be_empty
+    end
+  end
+
+  before do
+    wrapper_class.class_eval { attr_accessor :test }
+  end
+=begin
+    it 'extracts arguments by conditions' do
+      wrapper_class.class_eval do
+        attr_accessor :i
+        argument(:arg, if: Symbol) { |_| self.i = (i || 0) + 1 }
+      end
+      expect_any_instance_of(WrapIt::CaptureArray)
+        .to receive(:capture!).with(Symbol).and_call_original
+      expect(wrapper(:test, :multiple, :args).i).to eq 3
+    end
+
+    it 'extracts arguments to setters' do
+      wrapper_class.class_eval { argument :test }
+      expect(wrapper(:test).test).to be_true
+    end
+=end
+
+#    it 'extracts only first arguments with first_only: true' do
+#      wrapper_class.class_eval do
+#        attr_accessor :i
+#        argument(:arg, if: Symbol, first_only: true) do |_|
+#          self.i = (i || 0) + 1
+#        end
+#      end
+#      expect_any_instance_of(WrapIt::CaptureArray)
+#        .to receive(:capture_first!).and_call_original
+#      expect(wrapper(:test, :multiple, :args).i).to eq 1
+#    end
+
+=begin
+  # class methods
+  describe '.capture_arguments!' do
+    it 'extracts argument' do
+      wrapper_class.class_eval { argument :test }
+      args = %i(test args)
+      extracted = wrapper_class.capture_arguments!(args)
+      expect(extracted).to match_array %i(test)
+      expect(args).to match_array %i(args)
+    end
+
+    it 'extracts option' do
+      wrapper_class.class_eval { option :test_option }
+      args = [:test, :arg, test_option: 1]
+      extracted = wrapper_class.capture_arguments!(args)
+      expect(extracted).to match_array [test_option: 1]
+      expect(args).to match_array [:test, :arg]
+      args = [:test, :arg, test_option: 1, another: 0]
+      extracted = wrapper_class.capture_arguments!(args)
+      expect(extracted).to match_array [test_option: 1]
+      expect(args).to match_array [:test, :arg, another: 0]
+    end
+
+    it 'calls arguments extarct! method' do
+      wrapper_class.class_eval { argument :test }
+      args = double(%i(test args))
+      expect(args).to receive(:is_a?).with(Array).and_return(true)
+      expect(args).to receive(:extract_options!).and_return({})
+      expect(args).to receive(:extract!).with(:test).and_return([])
+      wrapper_class.extract_arguments!(args)
+    end
+  end
+
+  describe '#capture_arguments!' do
+    it 'calls block for finded arguments in instance context' do
+      wrapper_class.class_eval do
+        argument(:test) { html_class << 'test' }
+      end
+      wrapper.send(:capture_arguments!, %i(test args))
+      expect(wrapper.html_class).to include 'test'
+    end
+
+    it 'calls block for finded options in instance context' do
+      wrapper_class.class_eval do
+        option(:test_me) { html_class.push 'test' }
+      end
+      wrapper.send(:capture_arguments!, [test_me: :args])
+      expect(wrapper.html_class).to include 'test'
+    end
+  end
+=end
+end

data/spec/lib/base_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe WrapIt::Base do
+describe WrapIt::Base, type: :wrapped do
   it 'have #tag getter' do
     expect(successor.tag).to eq 'div'
   end
@@ -14,25 +14,8 @@ describe WrapIt::Base do
     expect(successor(tag: 'p').tag).to eq 'p'
   end
 
-  it 'extends @arguments with ArgumentsArray module' do
-    args = nil
-    successor_class.class_eval { after_initialize { args = @arguments } }
-    successor
-    expect(args).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 } }
+    successor_class.class_eval { after_initialize { html_class << :a } }
     expect(successor.html_class).to eq %w(a)
   end
 
@@ -44,10 +27,4 @@ describe WrapIt::Base 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

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

data/spec/lib/container_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe WrapIt::Container do
+describe WrapIt::Container, type: :wrapped do
 #  it 'not collects children without deffered_render' do
 #  end
 end

data/spec/lib/derived_attributes_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe WrapIt::DerivedAttributes do
+describe WrapIt::DerivedAttributes, type: :wrapped do
   describe '::get_derived' do
     it 'retrieves nil by default' do
       expect(wrapper_class.get_derived(:@var)).to be_nil

data/spec/lib/enums_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe WrapIt::Enums do
+describe WrapIt::Enums, type: :wrapped do
   it_behaves_like 'Base module'
 
   context 'wrapper have `kind` enum' do
@@ -26,7 +26,6 @@ describe WrapIt::Enums 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
@@ -83,7 +82,7 @@ describe WrapIt::Enums do
       @wrapper = nil
       expect(wrapper(kind: :no).kind).to eq :white
       @wrapper = nil
-      expect(wrapper(:black, kind: :no).kind).to eq :black
+      expect(wrapper(:black, kind: :no).kind).to eq :white
     end
   end
 end