arbo 1.2.0

data/lib/arbo/html/tag.rb

@@ -0,0 +1,220 @@
+require 'erb'
+
+module Arbo
+  module HTML
+
+    class Tag < Element
+      attr_reader :attributes
+
+      # See: http://www.w3.org/html/wg/drafts/html/master/syntax.html#void-elements
+      SELF_CLOSING_ELEMENTS = [ :area, :base, :br, :col, :embed, :hr, :img, :input, :keygen, :link,
+                            :menuitem, :meta, :param, :source, :track, :wbr ]
+
+      def initialize(*)
+        super
+        @attributes = Attributes.new
+      end
+
+      def build(*args)
+        super
+        attributes = extract_arguments(args)
+        self.content = args.first if args.first
+
+        for_value = attributes[:for]
+        unless for_value.is_a?(String) || for_value.is_a?(Symbol)
+          set_for_attribute(attributes.delete(:for))
+        end
+
+        attributes.each do |key, value|
+          set_attribute(key, value)
+        end
+      end
+
+      def extract_arguments(args)
+        if args.last.is_a?(Hash)
+          args.pop
+        else
+          {}
+        end
+      end
+
+      def set_attribute(name, value)
+        @attributes[name.to_sym] = value
+      end
+
+      def get_attribute(name)
+        @attributes[name.to_sym]
+      end
+      alias :attr :get_attribute
+
+      def has_attribute?(name)
+        @attributes.has_key?(name.to_sym)
+      end
+
+      def remove_attribute(name)
+        @attributes.delete(name.to_sym)
+      end
+
+      def id
+        get_attribute(:id)
+      end
+
+      # Generates and id for the object if it doesn't exist already
+      def id!
+        return id if id
+        self.id = object_id.to_s
+        id
+      end
+
+      def id=(id)
+        set_attribute(:id, id)
+      end
+
+      def add_class(class_names)
+        class_list.add class_names
+      end
+
+      def remove_class(class_names)
+        class_list.delete(class_names)
+      end
+
+      # Returns a string of classes
+      def class_names
+        class_list.to_s
+      end
+
+      def class_list
+        list = get_attribute(:class)
+
+        case list
+        when ClassList
+          list
+        when String
+          set_attribute(:class, ClassList.build_from_string(list))
+        else
+          set_attribute(:class, ClassList.new)
+        end
+      end
+
+      def to_s
+        indent(opening_tag, content, closing_tag).html_safe
+      end
+
+      def render_in(context = arbo_context)
+        indent_in_context(context)
+      end
+
+      private
+
+      def opening_tag
+        "<#{tag_name}#{attributes_html}>"
+      end
+
+      def closing_tag
+        "</#{tag_name}>"
+      end
+
+      INDENT_SIZE = 2
+
+      def indent(open_tag, child_content, close_tag)
+        spaces = ' ' * indent_level * INDENT_SIZE
+
+        html = ""
+
+        if no_child? || child_is_text?
+          if self_closing_tag?
+            html << spaces << open_tag.sub( />$/, '/>' )
+          else
+            # one line
+            html << spaces << open_tag << child_content << close_tag
+          end
+        else
+          # multiple lines
+          html << spaces << open_tag << "\n"
+          html << child_content # the child takes care of its own spaces
+          html << spaces << close_tag
+        end
+
+        html << "\n"
+
+        html
+      end
+
+      def indent_in_context(context)
+        spaces = ' ' * indent_level * INDENT_SIZE
+
+        pos = context.output_buffer.length
+
+        if no_child? || child_is_text?
+          if self_closing_tag?
+            context.output_buffer << spaces << opening_tag.sub( />$/, '/>' ).html_safe
+          else
+            # one line
+            context.output_buffer << spaces << opening_tag.html_safe
+            children.render_in(context)
+            context.output_buffer << closing_tag.html_safe
+          end
+        else
+          # multiple lines
+          context.output_buffer << spaces << opening_tag.html_safe << "\n"
+          children.render_in(context)
+          context.output_buffer << spaces << closing_tag.html_safe
+        end
+
+        context.output_buffer << "\n"
+
+        context.output_buffer[pos..].html_safe
+      end
+
+      def self_closing_tag?
+        SELF_CLOSING_ELEMENTS.include?(tag_name.to_sym)
+      end
+
+      def no_child?
+        children.empty?
+      end
+
+      def child_is_text?
+        children.size == 1 && children.first.is_a?(TextNode)
+      end
+
+      def attributes_html
+        " #{attributes}" if attributes.any?
+      end
+
+      def set_for_attribute(record)
+        return unless record
+        # set_attribute :id, ActionController::RecordIdentifier.dom_id(record, default_id_for_prefix)
+        # add_class ActionController::RecordIdentifier.dom_class(record)
+        set_attribute :id, dom_id_for(record)
+        add_class dom_class_name_for(record)
+      end
+
+      def dom_class_name_for(record)
+        if record.class.respond_to?(:model_name)
+          record.class.model_name.singular
+        else
+          record.class.name.underscore.gsub("/", "_")
+        end
+      end
+
+      def dom_id_for(record)
+        id = if record.respond_to?(:to_key)
+               record.to_key
+             elsif record.respond_to?(:id)
+               record.id
+             else
+               record.object_id
+             end
+
+        [default_id_for_prefix, dom_class_name_for(record), id].compact.join("_")
+      end
+
+      def default_id_for_prefix
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/arbo/html/text_node.rb

@@ -0,0 +1,43 @@
+require 'erb'
+
+module Arbo
+  module HTML
+
+    class TextNode < Element
+
+      builder_method :text_node
+
+      # Builds a text node from a string
+      def self.from_string(string)
+        node = new
+        node.build(string)
+        node
+      end
+
+      def add_child(*args)
+        raise "TextNodes do not have children"
+      end
+
+      def build(string)
+        @content = string
+      end
+
+      def class_list
+        []
+      end
+
+      def tag_name
+        nil
+      end
+
+      def to_s
+        ERB::Util.html_escape(@content.to_s)
+      end
+
+      def render_in(context)
+        to_s.tap { |s| context.output_buffer << s }
+      end
+    end
+
+  end
+end

data/lib/arbo/rails/forms.rb

@@ -0,0 +1,101 @@
+module Arbo
+  module Rails
+    module Forms
+
+      class FormBuilderProxy < Arbo::Component
+        attr_reader :form_builder
+
+        # Since label and select are Arbo Elements already, we must
+        # override it here instead of letting method_missing
+        # deal with it
+        def label(*args)
+          proxy_call_to_form :label, *args
+        end
+
+        def select(*args)
+          proxy_call_to_form :select, *args
+        end
+
+        def respond_to_missing?(method, include_all)
+          if form_builder && form_builder.respond_to?(method, include_all)
+            true
+          else
+            super
+          end
+        end
+
+        private
+
+        def proxy_call_to_form(method, *args, &block)
+          text_node form_builder.send(method, *args, &block)
+        end
+
+        def method_missing(method, *args, &block)
+          if form_builder && form_builder.respond_to?(method)
+            proxy_call_to_form(method, *args, &block)
+          else
+            super
+          end
+        end
+
+      end
+
+      class FormForProxy < FormBuilderProxy
+        builder_method :form_for
+
+        def build(resource, form_options = {}, &block)
+          form_string = helpers.form_for(resource, form_options) do |f|
+            @form_builder = f
+          end
+
+          @opening_tag, @closing_tag = split_string_on(form_string, "</form>")
+          super(&block)
+        end
+
+        def fields_for(*args, &block)
+          insert_tag FieldsForProxy, form_builder, *args, &block
+        end
+
+        def split_string_on(string, match)
+          return "" unless string && match
+          part_1 = string.split(Regexp.new("#{match}\\z")).first
+          [part_1, match]
+        end
+
+        def opening_tag
+          @opening_tag || ""
+        end
+
+        def closing_tag
+          @closing_tag || ""
+        end
+
+      end
+
+      class FieldsForProxy < FormBuilderProxy
+
+        def build(form_builder, *args, &block)
+          form_builder.fields_for(*args) do |f|
+            @form_builder = f
+          end
+
+          super(&block)
+        end
+
+        def to_s
+          children.to_s
+        end
+
+        def render_in(context)
+          children.collect do |element|
+            element.render_in_or_to_s(context)
+          end.join('')
+        end
+
+      end
+
+    end
+  end
+end
+
+

data/lib/arbo/rails/rendering.rb

@@ -0,0 +1,17 @@
+module Arbo
+  module Rails
+    module Rendering
+
+      def render(*args)
+        rendered = helpers.render(*args)
+        case rendered
+        when Arbo::Context
+          current_arbo_element.add_child rendered
+        else
+          text_node rendered
+        end
+      end
+
+    end
+  end
+end

data/lib/arbo/rails/template_handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+ActionView::Base.class_eval do
+  def capture(*args)
+    value = nil
+    buffer = with_output_buffer { value = yield(*args) }
+
+    # Override to handle Arbo elements inside helper blocks.
+    # See https://github.com/rails/rails/issues/17661
+    # and https://github.com/rails/rails/pull/18024#commitcomment-8975180
+    value = value.to_s if value.is_a?(Arbo::Element)
+
+    if (string = buffer.presence || value) && string.is_a?(String)
+      ERB::Util.html_escape string
+    end
+  end
+end
+
+module Arbo
+  module Rails
+    class TemplateHandler
+      def call(template, source = nil)
+        source = template.source unless source
+
+        <<-END
+        Arbo::Context.new(assigns, self) {
+          #{source}
+        }.render_in(self).html_safe
+        END
+      end
+    end
+  end
+end
+
+ActionView::Template.register_template_handler :arb, Arbo::Rails::TemplateHandler.new

data/lib/arbo/rails.rb

@@ -0,0 +1,5 @@
+require 'arbo/rails/template_handler'
+require 'arbo/rails/forms'
+require 'arbo/rails/rendering'
+
+Arbo::Element.send :include, Arbo::Rails::Rendering

data/lib/arbo/version.rb

@@ -0,0 +1,3 @@
+module Arbo
+  VERSION = '1.2.0'
+end

data/lib/arbo.rb

@@ -0,0 +1,21 @@
+require 'active_support/core_ext/string/output_safety'
+require 'active_support/deprecation'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/inflector'
+
+module Arbo
+end
+
+require 'arbo/element'
+require 'arbo/context'
+require 'arbo/html/attributes'
+require 'arbo/html/class_list'
+require 'arbo/html/tag'
+require 'arbo/html/text_node'
+require 'arbo/html/document'
+require 'arbo/html/html5_elements'
+require 'arbo/component'
+
+if defined?(Rails)
+  require 'arbo/rails'
+end