hensel 0.0.1

data/lib/hensel/configuration.rb

@@ -0,0 +1,37 @@
+module Hensel
+  class Configuration
+    # Define the accessor as boolean method
+    def self.attr_boolean_accessor(*keys)
+      keys.each do |key|
+        attr_accessor key
+        define_method("#{key}?"){ !!__send__(key) }
+      end
+    end
+
+    attr_boolean_accessor :bootstrap
+    attr_boolean_accessor :escape_html
+    attr_boolean_accessor :indentation
+    attr_boolean_accessor :last_item_link
+
+    attr_accessor :attr_wrapper, :whitespace, :parent_element, :richsnippet
+
+    def initialize
+      @bootstrap      = false
+      @escape_html    = true
+      @indentation    = true
+      @last_item_link = false
+      @richsnippet    = :microdata # [:microdata, :rdfa, :nil]
+      @attr_wrapper   = "'"
+      @whitespace     = "  "
+      @parent_element = :ul 
+    end
+
+    def [](key)
+      instance_variable_get(:"@#{key}")
+    end
+
+    def []=(key, value)
+      instance_variable_set(:"@#{key}", value)
+    end
+  end
+end

data/lib/hensel/filters.rb

@@ -0,0 +1,47 @@
+module Hensel
+  module Filters
+    extend self
+
+    def register(key, name, block)
+      filters[key][name] = block
+    end
+
+    def filters
+      @filters ||= { filters: {}, richsnippets: {} }
+    end
+
+    register :richsnippets, :microdata, ->(this){
+      return if this.renderer
+      this.renderer = ->(that){
+        node(:li, options.merge(itemtype: "http://data-vocabulary.org/Breadcrumb", itemscope: true)) do
+          if !Hensel.configuration.last_item_link? && item.last?
+            node(:span, itemprop: :title){ item.text }
+          else
+            node(:a, href: item.url, itemprop: :url) do
+              node(:span, itemprop: :title){ item.text }
+            end
+          end
+        end
+      }
+    }
+    
+    register :richsnippets, :rdfa, ->(this){
+      return if this.renderer
+      append_attribute(:"xmlns:v", "http://rdf.data-vocabulary.org/#", this.parent.options)
+      this.renderer = ->(that){
+        node(:li, options.merge(typeof: "v:Breadcrumb")) do
+          if !Hensel.configuration.last_item_link? && item.last?
+            node(:span, property: "v:title"){ item.text }
+          else
+            node(:a, href: item.url, rel: "v:url", property: "v:title"){ item.text }
+          end
+        end
+      }
+    }
+    
+    register :filters, :bootstrap, ->(this){
+      append_attribute(:class, "breadcrumb", options)
+      append_attribute(:class, "active", items.last.options)
+    }
+  end
+end

data/lib/hensel/helpers/tag_helpers.rb

@@ -0,0 +1,113 @@
+module Hensel
+  module Helpers
+    module TagHelpers
+      ESCAPE_VALUES = {
+        "'" => "'",
+        "&" => "&",
+        "<" => "&lt;",
+        ">" => "&gt;",
+        '"' => "&quot;"
+      }
+      ESCAPE_REGEXP = Regexp.union(*ESCAPE_VALUES.keys)
+      BOOLEAN_ATTRIBUTES = [
+        :autoplay,
+        :autofocus,
+        :formnovalidate,
+        :checked,
+        :disabled,
+        :hidden,
+        :loop,
+        :multiple,
+        :muted,
+        :readonly,
+        :required,
+        :selected,
+        :declare,
+        :defer,
+        :ismap,
+        :itemscope,
+        :noresize,
+        :novalidate
+      ]
+  
+      def content_tag(name, content = nil, **options, &block)
+        base = tag(name, options)
+        content = instance_eval(&block) if !content && block_given?
+        if indentation?
+          indent = options.fetch(:indent, 0)
+          base << "\n"
+          base << (content.strip.start_with?("<") ? content : (whitespace(indent + 1)) + content)
+          base << "\n"
+          base << "#{whitespace(indent)}</#{name}>"
+        else
+          "#{base}#{content}</#{name}>"
+        end
+      end
+  
+      def tag(name, indent: 0, **options)
+        "#{indentation? ? whitespace(indent) : ""}<#{name}#{tag_attributes(options)}>"
+      end
+  
+      def append_attribute(attribute, value, hash)
+        if hash[attribute]
+          unless hash[attribute].to_s.split(" ").include?(value)
+            hash[attribute] = (Array(hash[attribute]) << value) * " " 
+          end
+        else
+          hash.merge!(attribute => value)
+        end
+      end
+  
+      private
+  
+      def tag_attributes(options)
+        return '' if options.nil?
+        attributes = options.map do |k, v|
+          next if v.nil? || v == false
+          if v.is_a?(Hash)
+            nested_values(k, v)
+          elsif BOOLEAN_ATTRIBUTES.include?(k)
+            %(#{k}=#{attr_wrapper}#{k}#{attr_wrapper})
+          else
+            %(#{k}=#{attr_wrapper}#{h(v)}#{attr_wrapper})
+          end
+        end.compact
+        attributes.empty? ? '' : " #{attributes * ' '}"
+      end
+  
+      def nested_values(attribute, hash)
+        hash.map do |k, v|
+          if v.is_a?(Hash)
+            nested_values("#{attribute}-#{k.to_s}", v)
+          else
+            %(#{attribute}-#{k.to_s}=#{attr_wrapper}#{h(v)}#{attr_wrapper}")
+          end
+        end * ' '
+      end
+
+      def h(string)
+        Hensel.configuration.escape_html? ? escape_html(string) : string
+      end
+  
+      def escape_html(string)
+        string.to_s.gsub(ESCAPE_REGEXP) { |c| ESCAPE_VALUES[c] }
+      end
+  
+      def attr_wrapper
+        @attr_wrapper ||= Hensel.configuration.attr_wrapper
+      end
+  
+      def whitespace(indent = nil)
+        if indent.nil?
+          @whitespace ||= Hensel.configuration.whitespace
+        else
+          whitespace * indent
+        end
+      end
+  
+      def indentation?
+        @indentation ||= Hensel.configuration.indentation?
+      end
+    end
+  end
+end

data/lib/hensel/helpers.rb

@@ -0,0 +1,9 @@
+require 'hensel/builder'
+
+module Hensel
+  module Helpers
+    def breadcrumbs
+      @breadcrumbs ||= Builder.new
+    end
+  end
+end

data/lib/hensel/version.rb

@@ -0,0 +1,3 @@
+module Hensel
+  VERSION = "0.0.1"
+end

data/lib/hensel.rb

@@ -0,0 +1,29 @@
+require "hensel/version"
+require "hensel/configuration"
+require "hensel/builder"
+require "hensel/helpers"
+
+module Hensel
+  extend self
+
+  # Yields Hensel configuration block
+  # @example
+  #   Hensel.configure do |config|
+  #     config.attr_wrapper = '"'
+  #   end
+  # @see Hensel::Configuration
+  def configure
+    yield configuration
+    configuration
+  end
+
+  # Returns Hensel configuration
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Resets Hensel configuration
+  def reset_configuration!
+    @configuration = nil
+  end
+end

data/spec/builder_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe Hensel::Builder do
+  let(:builder){ Hensel::Builder.new }
+
+  describe "#add" do
+    context "with basic usage" do
+      it "returns an instance of Builder::Item" do
+        expect(builder.add("Index", "/")).to be_an_instance_of(Hensel::Builder::Item)
+      end
+
+      it "adds an instance of Builder::Item to items" do
+        builder.add("Boom", "/boom")
+        expect(builder.items.last).to be_an_instance_of(Hensel::Builder::Item)
+        expect(builder.items.last.text).to eq("Boom")
+      end
+
+      it "allows to set options as the attribute of Builder::Item" do
+        builder.add("Foo", "/foo", class: "optional-class", id: "foo-id")
+        expect(builder.render).to have_tag(:li, class: "optional-class", id: "foo-id")
+      end
+    end
+
+    context "with optional usage" do
+      it "returns an instance of Builder::Item" do
+        expect(builder.add(text: "Index", url: "/")).to be_an_instance_of(Hensel::Builder::Item)
+      end
+
+      it "adds an instance of Builder::Item to items" do
+        builder.add(text: "Boom", url: "/boom")
+        expect(builder.items.last).to be_an_instance_of(Hensel::Builder::Item)
+        expect(builder.items.last.text).to eq("Boom")
+      end
+
+      it "allows to set options as the attribute of Builder::Item" do
+        builder.add(text: "Foo", url: "/foo", class: "optional-class", id: "foo-id")
+        expect(builder.render).to have_tag(:li, class: "optional-class", id: "foo-id")
+      end
+    end
+  end
+
+  describe "#remove" do
+    context "with text" do
+      it "removes the item by text from items" do
+        tested = builder.add("Tested", "/tested")
+        builder.add("Sample", "/sample")
+        builder.remove("Tested")
+        expect(builder.items.any?{|x| x.text == tested.text }).to be_false
+      end
+    end
+
+    context "with block" do
+      it "removes the item by result of block from items" do
+        tested = builder.add("Tested", "/tested")
+        sample = builder.add("Sample", "/sample")
+        builder.remove{|x| x.url == "/sample" }
+        expect(builder.items.any?{|x| x.text == tested.text }).to be_true
+        expect(builder.items.any?{|x| x.text == sample.text }).to be_false
+      end
+    end
+  end
+
+  describe "#render" do
+    context "with bootstrap" do
+      before { Hensel.configuration.bootstrap = true }
+      before(:each) do
+        builder.add("Index", "/", class: "dummy-class")
+        builder.add("Dummy", "/dummy", class: "dummy-class")
+      end
+      subject { builder.render }
+
+      it "respects the bootstrap style" do
+        expect(subject).to have_tag(:ul, with: { class: "breadcrumb" }) do
+          with_tag "li:last-child", class: "active"
+        end
+      end
+
+      it "respects the microdata rule" do
+        expect(subject).to have_tag(:ul, with: { class: "breadcrumb" }) do
+          with_tag :li, with: { itemtype: "http://data-vocabulary.org/Breadcrumb", itemscope: "itemscope" }
+          with_tag "li > a", with: { href: "/", itemprop: "url" }
+          with_tag "li > a > span", with: { itemprop: "title" }
+        end
+      end
+
+      after { Hensel.configuration.bootstrap = false }
+    end
+
+    context "with bootstrap and without richsnippet" do
+      before(:all) do
+        Hensel.configuration.richsnippet = nil
+        Hensel.configuration.bootstrap = true
+      end
+      before(:each) do
+        builder.add("Index", "/", class: "dummy-class")
+        builder.add("Dummy", "/dummy", class: "dummy-class")
+      end
+      subject { builder.render }
+
+      it "respects the bootstrap style" do
+        expect(subject).to have_tag(:ul, with: { class: "breadcrumb" }) do
+          with_tag "li:last-child", class: "active"
+        end
+      end
+
+      it "does not respect the microdata rule" do
+        expect(subject).not_to have_tag(:li, with: { itemtype: "http://data-vocabulary.org/Breadcrumb", itemscope: "itemscope" })
+        expect(subject).not_to have_tag("li > a", text: "Index", with: { href: "/", itemprop: "url" })
+        expect(subject).not_to have_tag("li > a", text: "Dummy", with: { href: "/dummy", itemprop: "url" })
+      end
+
+      after { Hensel.configuration.bootstrap = false }
+    end
+
+    context "without bootstrap" do
+      before(:each) do
+        builder.add("Index", "/", class: "dummy-class")
+        builder.add("Dummy", "/dummy", class: "dummy-class")
+      end
+      subject { builder.render }
+      it "does not respect the bootstrap style" do
+        expect(subject).not_to have_tag(:ul, with: { class: "breadcrumb" })
+        expect(subject).not_to have_tag("li:last-child", with: { class: "active" })
+      end
+    end
+
+    context "attr_wrapper" do
+      before { Hensel.configuration.attr_wrapper = '"' }
+      before(:each){ builder.add("Index", "/", class: "dummy-class") }
+      subject { builder.render }
+      it { should_not match(/'/) }
+      it { should match(/"/) }
+      after { Hensel.reset_configuration! }
+    end
+
+    context "whitespace" do
+      before do
+        Hensel.configuration.richsnippet = nil
+        Hensel.configuration.whitespace = "  "
+      end
+      before(:each){ builder.add("Index", "/", class: "dummy-class") }
+      let(:fixture){
+        <<-FIXTURE.chomp
+<ul>
+  <li class='dummy-class'>
+    <span>
+      Index
+    </span>
+  </li>
+</ul>
+        FIXTURE
+      }
+      subject { builder.render }
+      it { should eq(fixture) }
+    end
+  end
+
+  describe "customized breadcrumbs" do
+    context "use customizable renderer instead of default renderer" do
+      before do
+        builder.add("Index", "/")
+        builder.add("Dummy", "/dummy")
+      end
+      subject do
+        builder.render do
+          node(:custom, href: item.url){ item.text }
+        end
+      end
+
+      it "can create the html of breadcrumb correctly" do
+        builder.add("Index", "/")
+        actual_html = builder.render do
+          node(:span){ "text: #{item.text}, url: #{item.url}" }
+        end
+        expect(subject).to have_tag(:ul) do
+          with_tag :custom, href: "/"
+          with_tag :custom, href: "/dummy"
+        end
+      end
+    end
+
+    context "parent element is not ul but div" do
+      before do
+        Hensel.configuration.parent_element = :div
+        Hensel.configuration.bootstrap = false
+        builder.add("Index", "/")
+      end
+      subject { builder.render }
+
+      it "can set parent element for customizable breadcrumb" do
+        expect(subject).to have_tag(:div, { class: "breadcrumb" }) do
+          with_tag "li", class: "active"
+        end
+      end
+
+      after do
+        Hensel.configuration.parent_element = :ul
+        Hensel.configuration.bootstrap = false
+      end
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Hensel::Configuration do
+  describe ".attr_boolean_accessor" do
+    let(:configuration){ Hensel::Configuration.new }
+    it "can define an accessor and boolean methods" do
+      expect(configuration.respond_to?(:sample)).to be_false
+      Hensel::Configuration.attr_boolean_accessor :sample
+      expect(configuration.respond_to?(:sample)).to be_true
+    end
+  end
+
+  describe "#[]" do
+  end
+
+  describe "#[]=" do
+  end
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Hensel::Helpers do
+  let(:object){ Object.new }
+  before { object.extend Hensel::Helpers  }
+  subject{ object.breadcrumbs }
+  it { should be_an_instance_of(Hensel::Builder) }
+end

data/spec/item_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Hensel::Builder::Item do
+  let(:builder){ Hensel::Builder.new }
+
+  context "with escape_html" do
+    before(:all) do
+      Hensel.configuration.escape_html = true
+      Hensel.configuration.indentation = false
+    end
+    before(:each){ builder.add('\'&"<>', '/') }
+    subject { builder.items.last.text }
+    it { should eq('&#39;&amp;&quot;&lt;&gt;') }
+  end
+
+  context "without escape_html" do
+    before(:all) do 
+      Hensel.configuration.escape_html = false
+      Hensel.configuration.indentation = false
+    end
+    before(:each){ builder.add('\'&"<>', '/') }
+    subject { builder.items.last.text }
+    it { should eq('\'&"<>') }
+  end
+
+  describe "#render" do
+    let(:item) { Hensel::Builder::Item.new("index", "/") }
+    subject { item.render }
+    context "basic usage" do
+      it { should have_tag(:li){ with_tag(:a, href: "/") } }
+    end
+
+    context "with customized renderer" do
+      it "can be set to renderer" do
+        item.renderer = ->(this){ node(:custom, data: "sample"){ item.text } } 
+        should have_tag(:custom, text: "index", data: "sample")
+      end
+    end
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Hensel::Builder::Node do
+  let(:item) { Hensel::Builder::Item.new("index", "/") }
+  before { Hensel.configuration.indentation = false }
+
+  describe "#render" do
+  end
+
+  describe "#node" do
+    context "with block" do
+      subject { item.render }
+      it "can build html correctly" do
+        item.renderer = ->(this){ node(:div, class: "hey"){ "sample text" }}
+        should have_tag(:div, text: "sample text", class: "hey")
+      end
+
+      it "can build html correctly even when node is nested" do
+        item.renderer = ->(this){ node(:div, class: "hey"){ node(:span){ "nested text" } }}
+        should have_tag(:div, class: "hey") do
+          with_tag(:span, text: "nested text")
+        end
+      end
+
+      it "should support same hierarchy elements" do
+        item.renderer = ->(this){
+          node(:div) do
+            node(:span){ "one1" }
+            node(:span){ "one2" }
+          end
+        }
+        should have_tag(:div) do
+          with_tag(:span, text: "one1")
+          with_tag(:span, text: "one2")
+        end
+      end
+    end
+
+    context "without block" do
+      subject { item.render }
+      it "can build html correctly" do
+        item.renderer = ->(this){ node(:div, "sample text", class: "hey") }
+        should have_tag(:div, content: "sample text", class: "hey")
+      end
+
+      it "can build html correctly even when node is nested" do
+        item.renderer = ->(this){ node(:div, class: "hey"){ node(:span, "nested text") }}
+        should have_tag(:div, class: "hey") do
+          with_tag(:span, content: "nested text")
+        end
+      end
+
+      it "should support same hierarchy elements" do
+        item.renderer = ->(this){
+          node(:div) do
+            node(:span, "one1")
+            node(:span, "one2")
+          end
+        }
+        should have_tag(:div) do
+          with_tag(:span, text: "one1")
+          with_tag(:span, text: "one2")
+        end
+      end
+    end
+  end
+
+  describe "#item" do
+    subject { item.render }
+    it "can be referred from block" do
+      item.renderer = ->(this){ node(:div, item.text) }
+      should have_tag(:div, text: "index")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require File.expand_path('../../lib/hensel', __FILE__)
+require 'rspec-html-matchers'

data/spec/tag_helpers_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Hensel::Helpers::TagHelpers do
+  let(:helpers){ Object.new }
+  before { helpers.extend Hensel::Helpers::TagHelpers }
+
+  describe "#contegt_tag" do
+    context "with block" do
+      subject { helpers.content_tag(:div, class: "dummy-class"){ "hello" }}
+      it { should have_tag(:div, content: "hello", class: "dummy-class") }
+    end
+
+    context "without block" do
+      subject { helpers.content_tag(:div, "hello", class: "dummy-class")}
+      it { should have_tag(:div, content: "hello", class: "dummy-class") }
+    end
+
+    context "with indentation" do
+      before { Hensel.configuration.indentation = true }
+      subject { helpers.content_tag(:div, "hello", indent: 2, class: "dummy-class")}
+      it { expect(subject.start_with?("    ")).to be_true }
+    end
+
+    context "without indentation" do
+      before { Hensel.configuration.indentation = false }
+      subject { helpers.content_tag(:div, "hello", indent: 2, class: "dummy-class")}
+      it { expect(subject.start_with?("<div")).to be_true }
+    end
+  end
+
+  describe "#tag" do
+    subject { helpers.tag(:img, class: "sample-image", src: "sample.jpg", alt: "sample image") }
+    it { should have_tag(:img, class: "sample-image", src: "sample.jpg", alt: "sample image") }
+  end
+
+  describe "#append_attribute" do
+    subject { Hash.new }
+    before { helpers.append_attribute(:key, :value, subject) }
+    it { subject[:key].should eq(:value) }
+  end
+end