wrap_it 0.1.5 → 0.2.0

data/spec/frameworks/rails_app.rb

@@ -0,0 +1,61 @@
+# require 'rails'
+# require 'action_controller/railtie'
+
+# require 'sprockets/railtie'
+
+require 'action_controller/railtie'
+require 'action_view/railtie'
+require 'action_view/base'
+require 'action_controller/base'
+
+#
+# Simple Rails application for testing
+#
+#
+module RailsApp
+  #
+  # App class
+  #
+  class Application < Rails::Application
+    config.secret_token =
+      '572c86f5ede338bd8aba8dae0fd3a326aabababc98d1e6ce34b9f0'
+
+#    config.session_store :cookie_store, key: '_myproject_session'
+    config.active_support.deprecation = :stderr
+    config.root = File.dirname(__FILE__)
+#    config.root = File.join __FILE__, '..'
+    Rails.backtrace_cleaner.remove_silencers!
+    config.cache_store = :memory_store
+    config.consider_all_requests_local = true
+    config.eager_load = false
+
+    config.assets.enabled = false
+#    config.assets.enabled = true if ::Rails::VERSION::MAJOR < 4
+#    config.assets.cache_store =
+#      [:file_store, "#{config.root}/tmp/cache/assets/"]
+
+    routes.draw do
+      get  '/test' => 'rails_app/tests#index'
+    end
+  end
+
+  #
+  # Main controller
+  #
+#  class TestsController < ActionController::Base
+#    helper WrapIt.helpers
+
+#    def index
+#      render inline: @code
+#    end
+#  end
+end
+
+# configure rails application
+RailsApp::Application.configure do |app|
+#  app.middleware.use MyRackMiddleware
+end
+
+RailsApp::Application.initialize!
+
+defined?(Capybara) && Capybara.app = RailsApp::Application

data/spec/frameworks/sinatra_app.rb

@@ -0,0 +1,32 @@
+require 'sinatra'
+
+#
+# Simple Sinatra application for testing
+#
+class SinatraApp < Sinatra::Base
+  enable :sessions
+
+  get '/login' do
+    body 'Please log in'
+  end
+
+  post '/login' do
+    session[:user_email] = params[:user_email]
+    redirect to('/profile')
+  end
+
+  get '/profile' do
+    if user_email == session[:user_email]
+      body "Welcome, #{user_email}!"
+    else
+      redirect to('/login')
+    end
+  end
+end
+
+# configure sinatra application
+SinatraApp.configure do |app|
+#  app.use MyRackMiddleware
+end
+
+defined?(Capybara) && Capybara.app = SinatraApp

data/spec/{rails → integration}/base_spec.rb

@@ -7,19 +7,19 @@ describe WrapIt::Base do
   end
 
   it 'renders base as div' do
-    render '<%= successor_helper %>'
+    render '<%= helper %>'
     expect(rendered).to have_tag 'div', count: 1
   end
 
   describe 'self.omit_content' do
     it 'captures block content' do
-      render '<%= successor_helper do %>Some text<% end %>'
+      render '<%= helper do %>Some text<% end %>'
       expect(rendered).to have_tag 'div', count: 1, text: /Some text/
     end
 
     it 'omits block content with omit_content' do
       successor_class.class_eval { omit_content }
-      render '<%= successor_helper do %>Some text<% end %>'
+      render '<%= helper do %>Some text<% end %>'
       expect(rendered).to have_tag 'div', count: 1, text: ''
     end
   end
@@ -38,26 +38,26 @@ describe WrapIt::Base do
 
   describe '#wrap' do
     it 'wraps with WrapIt::Base by default' do
-      render '<%= successor_helper(tag: :p) { |s| s.wrap } %>'
+      render '<%= helper(tag: :p) { |s| s.wrap } %>'
       expect(rendered).to have_tag 'div > p'
     end
 
     it 'wraps with WrapIt::Base and creating options' do
-      render '<%= successor_helper(tag: :p) { |s| s.wrap tag: :nav } %>'
+      render '<%= helper(tag: :p) { |s| s.wrap tag: :nav } %>'
       expect(rendered).to have_tag 'nav > p'
     end
 
     it 'wraps with class and creating options' do
       render <<-EOL
         <% w = Class.new(WrapIt::Base) { switch :sw, html_class: 'act' } %>
-        <%= successor_helper(tag: :p) { |s| s.wrap w, :sw, tag: :nav } %>'
+        <%= helper(tag: :p) { |s| s.wrap w, :sw, tag: :nav } %>'
       EOL
       expect(rendered).to have_tag 'nav.act > p'
     end
 
     it 'wraps with block' do
       render <<-EOL
-        <%= successor_helper(tag: :p) { |s| s.wrap do
+        <%= helper(tag: :p) { |s| s.wrap do
           |w| w.add_html_class 'nav'
         end } %>'
       EOL

data/spec/integration/container_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe WrapIt::Container do
+  before do
+    successor_class.class_eval do
+      default_tag 'ul'
+      child :item, tag: 'li'
+    end
+  end
+
+  def list_erb(args = '')
+    <<-EOL
+      <%= helper(#{args}) 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
+  end
+
+  it 'renders as ul' do
+    render '<%= helper %>'
+    expect(rendered).to have_tag 'ul', count: 1
+    expect(rendered).to_not have_tag 'ul > *'
+  end
+
+  it 'renders child items' do
+    render list_erb
+    expect(rendered).to have_tag 'ul > li', count: 6
+  end
+
+  it 'renders child items deffered' do
+    render list_erb(':deffered_render')
+    expect(rendered).to have_tag 'ul > li', count: 6
+  end
+
+  it 'drops content child items with omit_content' do
+    successor_class.class_eval { omit_content }
+    render list_erb
+    expect(rendered).to have_tag 'ul > li', count: 4
+  end
+
+  it 'drops content childs with omit_content and deffered' do
+    successor_class.class_eval { omit_content }
+    render list_erb(':deffered_render')
+    expect(rendered).to have_tag 'ul > li', count: 4
+  end
+
+  describe 'child helper method safety' do
+    it 'returns string with default options' do
+      expect(successor.item).to be_kind_of String
+    end
+
+    it 'returns string with omit_content' do
+      successor_class.class_eval { omit_content }
+      expect(successor.item).to be_kind_of String
+    end
+
+    it 'returns string with deffered' do
+      expect(successor(:deffered_render).item).to be_kind_of String
+    end
+
+    it 'returns string with deffered and omit' do
+      successor_class.class_eval { omit_content }
+      expect(successor(:deffered_render).item).to be_kind_of String
+    end
+  end
+
+  it 'not collects children without deffered_render' do
+    successor.item
+    expect(successor.children.size).to eq 0
+  end
+
+  it 'collects children with deffered_render' do
+    successor(:deffered_render).item
+    expect(successor.children.size).to eq 1
+  end
+
+  it 'avoids changing deffered_render after first item added' do
+    successor(:deffered_render).item
+    successor.deffered_render = false
+    expect(successor.deffered_render?).to be_true
+  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
+  end
+end

data/spec/integration/examples_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe WrapIt::Base do
+  describe 'usage exmaples' do
+    describe 'sections_explained' do
+      it '#1' do
+        successor_class.class_eval do
+          section :append, :prepend
+          place :prepend, before: :content
+          place :append, after: :content
+          after_initialize do
+            @prepend = options.delete(:prepend)
+            @append = options.delete(:append)
+          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'
+              self[:content] = content_tag('input', '', options)
+              options.clear
+              add_html_class 'input-group'
+            end
+          end
+        end
+        render <<-EOL
+          <%= helper prepend: '@', placeholder: 'Username' %>
+          <%= helper append: '.00' %>
+          <%= helper append: '.00', prepend: '$' %>
+        EOL
+        expect(rendered).to have_tag(
+          'div.input-group > span.input-group-addon[text()="@"]' \
+          ' + input.form-control[@type="text"][@placeholder="Username"]'
+        )
+        expect(rendered).to have_tag(
+          'div.input-group > input.form-control[@type="text"]' \
+          ' + span.input-group-addon[text()=".00"]'
+        )
+        expect(rendered).to have_tag(
+          'div.input-group > span.input-group-addon[text()="$"]' \
+          ' + input.form-control[@type="text"]' \
+          ' + span.input-group-addon[text()=".00"]'
+        )
+      end
+    end
+  end
+end

data/spec/integration/text_container_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe WrapIt::TextContainer do
+  it 'renders body' do
+    render '<%= helper "text" %>'
+    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'
+  end
+end

data/spec/lib/base_spec.rb

@@ -14,12 +14,6 @@ describe WrapIt::Base do
     expect(successor(tag: 'p').tag).to eq 'p'
   end
 
-  it 'drops @arguments after init' do
-    expect(
-      successor.instance_variable_get(:@arguments)
-    ).to be_nil
-  end
-
   it 'extends @arguments with ArgumentsArray module' do
     args = nil
     successor_class.class_eval { after_initialize { args = @arguments } }

data/spec/lib/container_spec.rb

@@ -1,11 +1,6 @@
 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
+#  it 'not collects children without deffered_render' do
 #  end
-
-  pending 'adds safe helpers'
 end

data/spec/lib/helpers_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe WrapIt do
+  describe 'self.register_module' do
+    it 'registers existing module' do
+      mod = Module.new
+      expect(WrapIt.register_module(mod)).to eq mod
+    end
+
+    it 'makes anonymous module if no module specified' do
+      expect(WrapIt.register_module).to be_kind_of Module
+    end
+
+    %i(register unregister).each do |method|
+      it "adds `#{method}` method to module" do
+        expect(WrapIt.register_module).to respond_to method
+      end
+    end
+
+    it 'supports prefix for helpers' do
+      mod = WrapIt.register_module prefix: 'test_'
+      mod.register :method, Object
+      expect(mod.instance_methods).to include :test_method
+    end
+  end
+end

data/spec/lib/html_class_spec.rb

@@ -7,7 +7,7 @@ describe WrapIt::HTMLClass 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)
+    expect(sub_class.new(template_wrapper).html_class).to eq %w(a d e b c)
   end
 
   describe '#html_class_prefix' do
@@ -23,7 +23,7 @@ describe WrapIt::HTMLClass do
     it 'returns derived value' do
       wrapper_class.class_eval { html_class_prefix 'e-' }
       sub_class = Class.new(wrapper_class)
-      expect(sub_class.new(template).html_class_prefix).to eq 'e-'
+      expect(sub_class.new(template_wrapper).html_class_prefix).to eq 'e-'
     end
   end
 

data/spec/lib/sections_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe WrapIt::Sections do
+  it_behaves_like 'Base module'
+
+  describe 'self.section' do
+    it 'adds sections' do
+      wrapper_class.send(:section, :test, :section)
+      expect(wrapper_class.sections).to include :test, :section
+    end
+
+    it 'drops duplicated sections' do
+      wrapper_class.send(:section, :test, :section, :test)
+      expect(wrapper_class.sections.size).to eq WrapIt::Base.sections.size + 2
+    end
+
+    it 'drops :begin and :end sections' do
+      wrapper_class.send(:section, :begin, :end)
+      expect(wrapper_class.sections.size).to eq WrapIt::Base.sections.size
+    end
+
+    it 'adds section to the end of placement' do
+      wrapper_class.section(:test)
+      expect(wrapper_class.placement.last).to eq :test
+    end
+  end
+
+  describe 'self.sections' do
+    it 'combines sections with derived' do
+      wrapper_class.send(:section, :test)
+      expect(wrapper_class.sections)
+        .to match_array(WrapIt::Base.sections + [:test])
+    end
+  end
+
+  describe 'self.placement' do
+    it 'sets places as parent placement + @sections for Base subclasses' do
+      wrapper_class.section(:test)
+      wrapper_class.place(:test, after: wrapper_class.placement.first)
+      expect(Class.new(wrapper_class).placement).to eq wrapper_class.placement
+    end
+
+    it 'clones sections' do
+      wrapper_class.placement
+      wrapper_class.instance_variable_get(:@placement).pop
+      expect(wrapper_class.placement.size)
+        .to eq wrapper_class.sections.size - 1
+    end
+  end
+
+  describe 'self.place' do
+    it 'places items right' do
+      wrapper_class.section(:test)
+      wrapper_class.place(:test, after: :begin)
+      expect(wrapper_class.placement.first).to eq :test
+      wrapper_class.place(:test, before: :end)
+      expect(wrapper_class.placement.last).to eq :test
+      first = wrapper_class.placement.first
+      wrapper_class.place(:test, after: first)
+      expect(wrapper_class.placement[1]).to eq :test
+      wrapper_class.place(:test, before: first)
+      expect(wrapper_class.placement.first).to eq :test
+    end
+  end
+
+  it 'adds hash-like access' do
+    wrapper_class.section(:test)
+    expect(wrapper[:test]).to eq ''
+    wrapper[:test] << 'test'
+    expect(wrapper[:test]).to eq 'test'
+  end
+end

data/spec/lib/text_container_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe WrapIt::TextContainer do
+  it { expect(wrapper_class.default_tag).to eq 'p' }
+
+  %i(text body).each do |option|
+    it "gets text from `#{option}` option" do
+      expect(wrapper(option => 'text').body).to eq 'text'
+    end
+
+    it "cleanups `#{option}` for options" do
+      expect(wrapper(option => 'text').options).to_not include option
+    end
+  end
+
+  it 'gets text from first String argument' do
+    expect(wrapper(:symbol, 'text', 'other').body).to eq 'text'
+  end
+end

data/spec/spec_helper.rb

@@ -3,6 +3,14 @@ require 'bundler'
 
 Bundler.require :default, :development
 
+if /sinatra/ =~ ENV['FRAMEWORK']
+  require File.join(File.dirname(__FILE__), 'frameworks', 'sinatra_app.rb')
+  FRAMEWORK = :sinatra
+elsif /rails/ =~ ENV['FRAMEWORK']
+  require File.join(File.dirname(__FILE__), 'frameworks', 'rails_app.rb')
+  FRAMEWORK = :rails
+end
+
 Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each do |file|
   require file
 end

data/spec/support/example_groups/integration_example_group.rb

@@ -0,0 +1,72 @@
+#
+# Helpers for integration testing
+#
+# @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+#
+module IntegrationExampleGroup
+  def self.included(base)
+    base.instance_eval do
+      metadata[:type] = :integration
+
+      after do
+        if Object.const_defined?(:Successor)
+          Object.send(:remove_const, :Successor)
+        end
+        Object.send(:remove_const, :Wrapper) if Object.const_defined?(:Wrapper)
+      end
+
+      if WrapIt.rails?
+        let(:template) do
+          @context ||= ActionView::LookupContext.new(
+            RailsApp::Application.root
+          )
+          template_class.new(ActionView::TemplateRenderer.new(@context))
+        end
+
+        let(:template_class) do
+          mod = helpers_module
+          Class.new(ActionView::Base) do
+            include mod
+          end
+        end
+      else
+      end
+
+      let(:rendered) { @rendered }
+
+      let(:helpers_module) do
+        Object.send(:remove_const, :Helpers) if Object.const_defined?(:Helpers)
+        Object.send(:const_set, :Helpers, WrapIt.register_module)
+        if described_class.is_a?(Class)
+          if Object.const_defined?(:Successor)
+            Object.send(:remove_const, :Successor)
+          end
+          Object.const_set(:Successor, successor_class)
+          Helpers.register :helper, 'Successor'
+        else
+          if Object.const_defined?(:Wrapper)
+            Object.send(:remove_const, :Wrapper)
+          end
+          Object.const_set(:Wrapper, wrapper_class)
+          Helpers.register :helper, 'Wrapper'
+        end
+        Helpers
+      end
+    end
+  end
+
+  def render(code)
+    if WrapIt.rails?
+      @rendered = template.render(inline: code)
+    else
+    end
+  end
+
+  RSpec.configure do |config|
+    config.include(
+      self,
+      type: :integration,
+      example_group: { file_path: /spec\/integration/ }
+    )
+  end
+end

data/spec/support/example_groups/wrap_it_example_group.rb

@@ -5,7 +5,7 @@
 #
 module WrapItExampleGroup
   BASE_MODULES = [WrapIt::HTMLClass, WrapIt::HTMLData, WrapIt::Switches,
-                  WrapIt::Enums, WrapIt::Renderer]
+                  WrapIt::Enums, WrapIt::Renderer, WrapIt::Sections]
 
   def self.included(base)
     base.instance_eval do
@@ -16,7 +16,7 @@ module WrapItExampleGroup
         @wrapper = nil
       end
 
-      let(:template) { Object.new }
+      let(:template_wrapper) { Object.new }
 
       let(:successor_class) { Class.new described_class }
 
@@ -32,11 +32,13 @@ module WrapItExampleGroup
   end
 
   def successor(*args, &block)
-    @successor ||= successor_class.new(template, *args, &block)
+    templ = respond_to?(:template) ? template : template_wrapper
+    @successor ||= successor_class.new(templ, *args, &block)
   end
 
   def wrapper(*args, &block)
-    @wrapper ||= wrapper_class.new(template, *args, &block)
+    templ = respond_to?(:template) ? template : template_wrapper
+    @wrapper ||= wrapper_class.new(templ, *args, &block)
   end
 
   RSpec.configure do |config|

data/wrap_it.gemspec

@@ -15,6 +15,9 @@ Gem::Specification.new do |spec|
   EOL
   spec.homepage      = 'https://github.com/cybernetlab/wrap_it'
   spec.license       = 'MIT'
+  spec.metadata      = {
+    'issue_tracker' => 'https://github.com/cybernetlab/wrap_it/issues'
+  }
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -22,9 +25,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '~> 1.3'
-  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake', '~> 10.1'
   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'
+  spec.add_development_dependency 'yard', '~> 0.8'
+  spec.add_development_dependency 'rspec', '~> 2.14'
+  spec.add_development_dependency 'rspec-html-matchers', '~> 0.4'
 end