html-native 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2ec4658fd7a7e2a040535c411ca661cc80291d705b59099c93b6eecd184fb35e
+  data.tar.gz: e96476a674a70ad4e28ba9ab223057bbc3bbdcab00ae91d1ff39c1788e383131
+SHA512:
+  metadata.gz: 85deca5f040b4268a9b3cf533483f2fbe91de270e5b6dbaf35817cea6363e49e008863481d24eea85c9c18123715caf21cfbe08f2f2c872cd844866ab95c956f
+  data.tar.gz: 7eca06fcf63a3159af0e2de5c4502ad5d969707de4c3f0221df07ca73b9d0b49e224edae049d8c6a5f59c1f390664c56221c9b74bc499ee4e213817c100ac6e6

data/lib/html-native.rb

@@ -0,0 +1,60 @@
+require "html-native/constants"
+require "html-native/builder"
+
+module HTMLComponent
+ 
+  # Excluded currently because it makes checking in `Builder` ugly
+  # Makes `include` and `extend` work exactly the same.
+  # It's a dirty hack based on laziness, and strict use of `extend` is preferred.
+  # def self.included(base)
+  #   base.extend(self)
+  # end
+
+  # Generates generation methods for each HTML5-valid tag. These methods have the 
+  # name of the tag. Note that this interferes with the builtin `p` method.
+  TAG_LIST.each do |tag|
+    HTMLComponent.define_method(tag) do |attrs = {}, &block|
+      attrs ||= {}
+      if block
+        body = block.call
+        Builder.new("<#{tag}#{attributes_list(tag, attrs)}>") + body + "</#{tag}>"
+      else
+        Builder.new("<#{tag}#{attributes_list(tag, attrs)}/>") 
+      end
+    end
+  end
+
+  def self.singleton(&block)
+    Module.new do
+      extend HTMLComponent
+      define_singleton_method :render, &block
+    end
+  end
+
+  # Checks if the attribute is valid for a given tag.
+  #
+  # For example, `class` and `hidden` are valid for everything, but `autoplay` 
+  # is valid for only `video` and `audio` tags, and invalid for all other tags.
+  def valid_attribute?(tag, attribute)
+    if LIMITED_ATTRIBUTES.key?(attribute.to_sym)
+      return LIMITED_ATTRIBUTES[attribute.to_sym].include?(tag.to_sym)
+    end
+    return !FORBIDDEN_ATTRIBUTES.include?(attribute)
+  end
+  
+  private
+
+  # Given a tag and a set of attributes as a hash, format the attributes to 
+  # HTML-valid form. If an attribute doesn't have a value or the value is 
+  # empty, it's treated as a boolean attribute and formatted as such.
+  def attributes_list(tag, attrs)
+    formatted = attrs.filter{|opt, value| valid_attribute?(tag, opt)}.map do |k,v| 
+      if v&.to_s.empty?
+        k.to_s
+      else
+        "#{k}=\"#{v}\"" # render this appropriately for numeric fields (might already)
+      end
+    end.join(" ")
+    formatted.empty? ? "" : " " + formatted
+  end
+end

data/lib/html-native/builder.rb

@@ -0,0 +1,27 @@
+require "html-native"
+module HTMLComponent
+  class Builder
+    def initialize(strings = [])
+      if strings.kind_of? String 
+        @strings = [strings]
+      else
+        @strings = strings.dup
+      end
+    end
+
+    def +(string)
+      if string.kind_of? Builder 
+        @strings << string
+      elsif string.kind_of? HTMLComponent
+        @strings << string.render
+      else
+        @strings << string.to_s
+      end
+      self
+    end
+
+    def to_s
+      @strings.join
+    end
+  end
+end

data/lib/html-native/collections.rb

@@ -0,0 +1,197 @@
+require "html-native"
+require "html-native/builder"
+
+module Enumerable
+  def component_map 
+    if block_given?
+      result = HTMLComponent::Builder.new
+      each do |e|
+        result += yield(e)
+      end
+      result
+    else
+      to_enum(:component_map)
+    end
+  end
+
+  def to_ol(attributes: {})
+    OrderedListComponent.new(self, attributes: attributes)
+  end
+  
+  def to_ul(attributes: {})
+    UnorderedListComponent.new(self, attributes: attributes)
+  end
+end
+
+class OrderedListComponent
+  include HTMLComponent
+
+  def initialize(data, attributes: {})
+    @list_data = data
+    @list_attributes = attributes[:list] || {}
+    @item_attributes = attributes[:item] || {}
+  end
+
+  def render(&block)
+    ol(@list_attributes) do
+      @list_data.component_map do |l|
+        li(@item_attributes) do
+          block_given? ? yield(l) : l.to_s
+        end
+      end
+    end
+  end
+end
+
+class UnorderedListComponent
+  include HTMLComponent
+
+  def initialize(data, attributes: {})
+    @list_data = data
+    @list_attributes = attributes[:list] || {}
+    @item_attributes = attributes[:item] || {}
+  end
+
+  def render(&block)
+    ul(@list_attributes) do
+      @list_data.component_map do |l|
+        li(@item_attributes) do
+          block_given? ? yield(l) : l.to_s
+        end
+      end
+    end
+  end
+end
+
+class ListComponent
+  def initialize(data, attributes: {}, ordered: false)
+    @list = ordered ? OrderedListComponent.new(data, attributes) : 
+                      UnorderedListComponent.new(data, attributes)
+  end
+
+  def render(&block)
+    @list.render(&block)
+  end
+end
+
+class TableRowComponent
+  include HTMLComponent
+
+  def initialize(data, attributes: {})
+    @data = data
+    @row_attributes = attributes[:row] || {}
+    @cell_attributes = attributes[:cell] || {}
+  end
+
+  def render(&block)
+    tr(@row_attributes) do
+      @data.component_map do |c|
+        td(@cell_attributes) {block_given? ? yield(c) : c}
+      end
+    end
+  end
+end
+
+# This needs some reworking, since it's not intuitive
+class TableComponent
+  include HTMLComponent
+
+  def initialize(header, rows, attributes: {})
+    @header = header
+    @rows = rows
+    @table_attributes = attributes[:table] || {}
+    @header_attributes = attributes[:header] || {}
+    @header_cell_attributes = attributes[:header_cell] || {}
+    @row_attributes = attributes[:row] || {}
+    @cell_attributes = attributes[:cell] || {}
+  end
+
+  # header options:
+  # array - use as header
+  # symbol - if :from_data, then use first row, if :none, set @header to nil
+  def self.from_array(data, attributes: {}, header: :none)
+    head = rows = nil
+    if header == :from_data
+      head = data[0]
+      rows = data[1..]
+    else
+      head = header.kind_of?(Array) ? header : nil
+      rows = data
+    end
+    new(head, rows, attributes: attributes)
+  end
+
+  def self.from_hash(data, attributes: {}, vertical: true)
+    if vertical
+      rowcount = data.values.map(&:length).max
+      rows = [] * rowcount
+      data.each do |k,col|
+        rowcount.times do |i|
+          rows[i] << (i < col.size ? col[i] : nil)
+        end
+      end
+      new(data.keys, rows, attributes: attributes)
+    else
+      rows = data.map do |k, v|
+        [k] + v
+      end
+      new(nil, rows, attributes: attributes)
+    end
+  end
+
+  def render(&block)
+    table(@table_attributes) do
+      if @header
+        tr(@row_attributes.merge(@header_attributes)) do
+          @header.component_map do |h|
+            th(@cell_attributes.merge(@header_cell_attributes)) {h}
+          end
+        end
+      else
+        Builder.new
+      end +
+      @rows.component_map do |row|
+        TableRowComponent.new(row, attributes: {row: @row_attributes, cell: @cell_attributes}).render(&block)
+      end
+    end
+  end
+end
+
+class DropdownComponent
+  include HTMLComponent
+
+  def initialize(choices, name, attributes: {})
+    @choices = choices
+    @name = name
+    @menu_attributes = attributes[:menu]
+    @item_attributes = attributes[:item]
+  end
+
+  def render(&block)
+    select(@menu_attributes.merge({name: @name, id: "#{@name}-dropdown"})) do
+      @choices.component_map do |c|
+        option(@item_attributes.merge({value: c})) {block_given? ? yield(c) : c}
+      end
+    end
+  end
+end
+
+class RadioGroupComponent
+  include HTMLComponent
+
+  def initialize(choices, name, attributes: {}, labelled: true)
+    @choices = choices
+    @name = name
+    @button_attributes = attributes[:button]
+    @label_attributes = attributes[:label]
+    @labelled = labelled
+  end
+
+  def render(&block)
+    @choices.component_map do |c|
+      id = "#{@name}-#{c}" 
+      input({type: "radio", id: id, name: @name, value: c}) +
+        (@labelled ? (label({for: id}) {block_given? ? yield(c) : c}) : nil)
+    end
+  end
+end

data/lib/html-native/constants.rb

@@ -0,0 +1,140 @@
+module HTMLComponent
+  TAG_LIST = [
+    :html, 
+    :base, :head, :link, :meta, :style, :title,
+    :body,
+    :address, :article, :aside, :footer, :h1, :h2, :h3, :h4, :h5, :h6, :header, 
+        :hgroup, :main, :nav, :section,
+    :blockquote, :dd, :div, :dl, :dt, :figcaption, :figure, :hr, :li, :ol, :p, :pre, :ul,
+    :a, :abbr, :b, :bdi, :bdo, :br, :cite, :code, :data, :dfn, :em, :i, :kbd, :mark, :q,
+        :rb, :rp, :rt, :rtc, :ruby, :s, :samp, :small, :span, :strong, :sub, :sup, :time, 
+        :u, :var, :wbr,
+    :area, :audio, :img, :map, :track, :video,
+    :embed, :iframe, :object, :param, :picture, :portal, :source,
+    :svg, :math,
+    :canvas, :noscript, :script,
+    :del, :ins,
+    :caption, :col, :colgroup, :table, :tbody, :td, :tfoot, :th, :thead, :tr,
+    :button, :datalist, :fieldset, :form, :input, :label, :legend, :meter, :optgroup,
+        :option, :output, :progress, :select, :textarea,
+    :details, :dialog, :menu, :summary,
+    :slot, :template
+  ] + (1..6).map{|i| :"h#{i}"}
+
+  def self.tags
+    TAG_LIST.dup
+  end
+
+  LIMITED_ATTRIBUTES = {
+    accept: [:form, :input],
+    "accept-charset": [:form],
+    action: [:form],
+    align: [:caption, :col, :colgroup, :hr, :iframe, :img, :table, 
+            :tbody, :td, :tfoot, :th, :thead, :tr],
+    allow: [:iframe],
+    alt: [:area, :img, :input],
+    async: [:script],
+    autocomplete: [:form, :input, :select, :textarea],
+    autofocus: [:button, :input, :select, :textarea],
+    autoplay: [:audio, :video],
+    buffered: [:audio, :video],
+    capture: [:input],
+    charset: [:meta, :script],
+    checked: [:input],
+    cite: [:blockquote, :del, :ins, :q],
+    cols: [:textarea],
+    colspan: [:td, :th],
+    content: [:meta],
+    controls: [:audio, :video],
+    coords: [:area],
+    crossorigin: [:audio, :img, :link, :script, :video],
+    csp: [:iframe],
+    data: [:object],
+    datatime: [:del, :ins, :time],
+    decoding: [:img],
+    default: [:track],
+    defer: [:script],
+    dirname: [:input, :textarea],
+    disabled: [:button, :fieldset, :input, :optgroup, 
+               :option, :select, :textarea],
+    download: [:a, :area],
+    enctype: [:form],
+    enterkeyhint: [:textarea],
+    "for": [:label, :output],
+    form: [:button, :fieldset, :input, :label, :meter, :object, 
+           :output, :progress, :select, :textarea],
+    formaction: [:input, :button],
+    formentype: [:button, :input],
+    formmethod: [:button, :input],
+    formnovalidate: [:button, :input],
+    formtarget: [:button, :input],
+    headers: [:td, :th],
+    height: [:canvas, :embed, :iframe, :img, :input, :object, :video],
+    high: [:meter],
+    href: [:a, :area, :base, :link],
+    hreflang: [:a, :area, :link],
+    "http-equiv": [:meta],
+    importance: [:iframe, :img, :link, :script],
+    integrity: [:link, :script],
+    inputmode: [:textarea],
+    ismap: [:img],
+    kind: [:track],
+    label: [:optgroup, :option, :track],
+    language: [:script],
+    loading: [:img, :iframe],
+    list: [:input],
+    loop: [:audio, :video],
+    low: [:meter],
+    max: [:input, :meter, :progress],
+    maxlength: [:input, :textarea],
+    minlength: [:input, :textarea],
+    media: [:a, :area, :link, :source, :style],
+    method: [:form],
+    min: [:input, :select],
+    multiple: [:input, :select],
+    muted: [:audio, :video],
+    name: [:button, :form, :fieldset, :iframe, :input, :object, 
+           :output, :select, :textarea, :map, :meta, :param],
+    novalidate: [:form],
+    open: [:details],
+    optimum: [:meter],
+    pattern: [:input],
+    ping: [:a, :area],
+    placeholder: [:input, :textarea],
+    poster: [:video],
+    preload: [:audio, :video],
+    readonly: [:input, :textarea],
+    referrerpolicy: [:a, :area, :iframe, :img, :link, :script],
+    rel: [:a, :area, :link],
+    required: [:input, :select, :textarea],
+    reversed: [:ol],
+    rows: [:textarea],
+    rowspan: [:td, :th],
+    sandbox: [:iframe],
+    scope: [:th],
+    scoped: [:style],
+    selected: [:option],
+    shape: [:a, :area],
+    size: [:input, :select],
+    sizes: [:link, :img, :source],
+    span: [:col, :colgroup],
+    src: [:audio, :embed, :iframe, :img, :input, :script, :source, :track, :video],
+    srcdoc: [:iframe],
+    srclang: [:track],
+    srcset: [:img, :source],
+    start: [:ol],
+    step: [:input],
+    summary: [:table],
+    target: [:a, :area, :base, :form],
+    type: [:button, :input, :embed, :object, :script, :source, :style, :menu],
+    usemap: [:img, :input, :object],
+    value: [:button, :data, :input, :li, :meter, :option, :progress, :param],
+    width: [:canvas, :embed, :iframe, :img, :input, :object, :video],
+    wrap: [:textarea]
+  }
+  
+  # These attributes are deprecated or outright forbidden. However, some people 
+  # might still try to use them. These attributes are expressly disallowed 
+  # during generation, and won't be included, even if provided.
+  FORBIDDEN_ATTRIBUTES = [:background, :bgcolor, :border, :color, :manifest]
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: html-native
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kellen Watt
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-01-25 00:00:00.000000000 Z
+dependencies: []
+description: An html generation DSL designed for fluid code creation.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/html-native.rb
+- lib/html-native/builder.rb
+- lib/html-native/collections.rb
+- lib/html-native/constants.rb
+homepage: https://github.com/KellenWatt/html-native
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Ruby-native html generation
+test_files: []