slacken 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ffc05a0da1b3b3fc3534666b1de2a36697448557
+  data.tar.gz: 7d0fda248b1f4a64500e5e6e92b3941adc8320ab
+SHA512:
+  metadata.gz: 8ee43ac2dbef90cf74aced8f4e940dde59d80bbbd693fdcc7d822624ea21f51b8a7a13e19345dc9d06cf3363c6c8e1c168e9811f2808484e7f7cc7dfcf0c9067
+  data.tar.gz: 19f4898e6ee95503572ea4bb70005f54d84779f647c93c1c982250685bed83b7f95acf7a4506347f8bc535776e4fd18864edb871bff1f71b071673babde0105d

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+html/
+pkg/
+vendor/cache/*.gem

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Tomoya Chiba
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# slacken
+
+## Description
+This gem translates a html source into a markup text for Slack.
+
+## Examples
+
+Sample input source and output texts are in `sample/`.
+
+```
+> require 'slacken'
+> puts Slacken.translate(File.read('sample/source.html'))
+# *Slacken*
+#
+# This gem translates a html source into *a markup text for Slack*.
+# <http://qiita.com|Qiita> uses this gem to decorate notification messages to Slack :trollface:.
+#
+# *Examples*
+#
+# *List*
+#
+# 1. Item 1
+# 2. _Item 2 (italic)_
+#     • [x] Checked
+#     • [ ] Unchecked
+# 3. *Item 3 (bold)*
+#     • Nested Item 1
+#     • Nested Item 2
+#
+# *Citation*
+#
+# > Qiita is a technical information sharing site for programmers.
+# >  Kobito is an application for technical information recording.
+#
+# *Source Code*
+#
+# ```class World
+#   def hello
+#     puts 'Hello, world!'
+#   end
+# end
+# ```
+#
+# *Image*
+#
+# This is a Qiita logo.
+#
+# -----------
+#
+# <http://cdn.qiita.com/assets/siteid-reverse-1949e989f9d8b2f6fad65a57292b2b01.png|Qiita logo>
+```
+
+## Install
+
+```
+$ gem install slacken
+```
+
+## License
+MIT

data/Rakefile

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit -1
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  rdoc.title = "slacken"
+end
+task :doc => :rdoc
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec

data/lib/slacken.rb

@@ -0,0 +1,21 @@
+module Slacken
+  require 'slacken/document_component'
+  require 'slacken/dom_container'
+  require 'slacken/render_element'
+  require 'slacken/rendering'
+  require 'slacken/node_type'
+  require 'slacken/slack_url'
+  require 'slacken/table_element'
+  require 'slacken/version'
+
+  class << self
+    def translate(html_source)
+      convert(html_source).to_s
+    end
+
+    def convert(html_source)
+      Slacken::DomContainer.parse_html(html_source)
+        .to_component.to_element
+    end
+  end
+end

data/lib/slacken/document_component.rb

@@ -0,0 +1,73 @@
+require 'forwardable'
+
+require 'slacken/document_component/elim_blanks'
+require 'slacken/document_component/elim_invalid_links'
+require 'slacken/document_component/elim_line_breaks'
+require 'slacken/document_component/extract_img_alt'
+require 'slacken/document_component/group_inlines'
+require 'slacken/document_component/group_indent'
+require 'slacken/document_component/sanitize_link_containers'
+require 'slacken/document_component/sanitize_special_tag_containers'
+require 'slacken/document_component/stringfy_checkbox'
+require 'slacken/document_component/stringfy_emoji'
+
+# Public: An intermediate object that is used when a HTML source is translated into a MarkupElement
+#         representing structure of a markup text.
+#         A DocumentComponent has tree structure and has child nodes as `children`.
+module Slacken
+  class DocumentComponent
+    include ElimBlanks
+    include ElimInvalidLinks
+    include ElimLineBreaks
+    include ExtractImgAlt
+    include GroupInlines
+    include GroupIndent
+    include SanitizeLinkContainers
+    include SanitizeSpecialTagContainers
+    include StringfyCheckbox
+    include StringfyEmoji
+
+    extend Forwardable
+    def_delegators :@type, :block?, :inline?
+
+    attr_reader :type, :attrs, :children
+
+    def initialize(type, children = [], attrs = {})
+      @type = NodeType.create(type)
+      @attrs = attrs
+      @children = children
+    end
+
+    def derive(new_children, updates = {})
+      self.class.new(
+        updates[:type] || type, new_children, updates[:attrs] || attrs)
+    end
+
+    # Public: Normalize this object's structure and convert it to MarkupElement.
+    def to_element
+      normalize.produce_element
+    end
+
+    def normalize
+      stringfy_emoji
+        .stringfy_checkbox
+        .extract_img_alt
+        .elim_invalid_links
+        .sanitize_link_containers
+        .sanitize_special_tag_containers
+        .group_inlines
+        .group_indent
+        .elim_blanks
+        .elim_line_breaks
+    end
+
+    # Private: Convert this element to a MarkupElement.
+    def produce_element
+      if type.member_of?(:table)
+        TableElement.new(children.map(&:produce_element))
+      else
+        RenderElement.new(type, children.map(&:produce_element), attrs)
+      end
+    end
+  end
+end

data/lib/slacken/document_component/elim_blanks.rb

@@ -0,0 +1,36 @@
+class Slacken::DocumentComponent
+  module ElimBlanks
+    # Private: Reject blank elements
+    def elim_blanks
+      case type.name
+      when :pre
+        self
+      else
+        derive(children.reject(&:blank?).map(&:elim_blanks))
+      end
+    end
+
+    def blank?
+      return @is_blank if !@is_blank.nil?
+      @is_blank =
+        case type.name
+        when :pre, :ul, :li, :br, :hr, :img, :checkbox
+          false
+        when :text, :emoji
+          content = attrs[:content]
+          content.nil? || !content.match(/\A\s*\Z/).nil?
+        else
+          children.empty? || children.all?(&:blank?)
+        end
+    end
+
+    def has_no_blanks?
+      case type.name
+      when :pre
+        true
+      else
+        !blank? && children.all?(&:has_no_blanks?)
+      end
+    end
+  end
+end

data/lib/slacken/document_component/elim_invalid_links.rb

@@ -0,0 +1,26 @@
+class Slacken::DocumentComponent
+  module ElimInvalidLinks
+    # Private: Eliminate internal links and blank links
+    def elim_invalid_links
+      if invalid_link?
+        derive(children.map(&:elim_invalid_links), type: :span)
+      else
+        derive(children.map(&:elim_invalid_links))
+      end
+    end
+
+    def invalid_link?
+      if type.member_of?(:a)
+        link = attrs[:href]
+        link.nil? ||
+          !link.match(%r{\Ahttps?://})
+      else
+        false
+      end
+    end
+
+    def has_no_invalid_links?
+      !invalid_link? && children.all?(&:has_no_invalid_links?)
+    end
+  end
+end

data/lib/slacken/document_component/elim_line_breaks.rb

@@ -0,0 +1,27 @@
+class Slacken::DocumentComponent
+  module ElimLineBreaks
+    # Private: Reject blank elements
+    def elim_line_breaks
+      case type.name
+      when :text
+        new_content = attrs[:content].gsub(/[\r\n]/, '')
+        derive(children, attrs: attrs.merge(content: new_content))
+      when :pre
+        self
+      else
+        derive(children.map(&:elim_line_breaks))
+      end
+    end
+
+    def has_no_line_breaks?
+      case type.name
+      when :text
+        !attrs[:content].match(/[\r\n]/)
+      when :pre
+        true
+      else
+        children.all?(&:has_no_line_breaks?)
+      end
+    end
+  end
+end

data/lib/slacken/document_component/extract_img_alt.rb

@@ -0,0 +1,12 @@
+class Slacken::DocumentComponent
+  module ExtractImgAlt
+    def extract_img_alt
+      if type.member_of?(:img)
+        child = self.class.new(:text, [], content: attrs[:alt] || attrs[:src])
+        derive([child])
+      else
+        derive(children.map(&:extract_img_alt))
+      end
+    end
+  end
+end

data/lib/slacken/document_component/group_indent.rb

@@ -0,0 +1,27 @@
+class Slacken::DocumentComponent
+  module GroupIndent
+    # Private: Wrap contents to indent.
+    #          Childrens of li or dd tags are wrapped.
+    def group_indent
+      if type.member_of?(:li, :dd)
+        head, *tails = children.map(&:group_indent)
+        derive([head, self.class.new(:indent, tails)])
+      else
+        derive(children.map(&:group_indent))
+      end
+    end
+
+    def indent_grouped?
+      if type.member_of?(:li, :dd)
+        head, tail = children
+        if tail
+          tail.type.member_of?(:indent) && tail.indent_grouped?
+        else
+          true
+        end
+      else
+        children.all?(&:indent_grouped?)
+      end
+    end
+  end
+end

data/lib/slacken/document_component/group_inlines.rb

@@ -0,0 +1,26 @@
+class Slacken::DocumentComponent
+  module GroupInlines
+    # Private: Group inline elements and wrap them in a wrapper node.
+    #          Wrapper nodes are introduced to group inline nodes in a paragraph.
+    def group_inlines
+      if block?
+        new_children = children.map(&:group_inlines).chunk(&:inline?).map do |is_inline, group|
+          is_inline ? self.class.new(:wrapper, group) : group
+        end.flatten
+        derive(new_children)
+      else
+        derive(children.map(&:group_inlines))
+      end
+    end
+
+    def inlines_grouped?
+      if type.member_of?(:wrapper)
+        true
+      elsif inline?
+        false
+      else
+        children.all?(&:inlines_grouped?)
+      end
+    end
+  end
+end

data/lib/slacken/document_component/sanitize_link_containers.rb

@@ -0,0 +1,40 @@
+class Slacken::DocumentComponent
+  module SanitizeLinkContainers
+    # Private: Sanitize not allowed tags in links.
+    def sanitize_link_containers
+      case type.name
+      when :img, :a, :iframe
+        derive(children.map(&:sanitize_in_link))
+      else
+        derive(children.map(&:sanitize_link_containers))
+      end
+    end
+
+    def sanitize_in_link
+      if type.allowed_in_link?
+        derive(children.map(&:sanitize_in_link))
+      else
+        # No block tags are allowed.
+        derive(children.map(&:sanitize_in_link), type: :span)
+      end
+    end
+
+    def link_sanitized?
+      case type.name
+      when :img, :a, :iframe
+        children.all?(&:list_containers_sanitized?)
+      else
+        children.all?(&:link_sanitized?)
+      end
+    end
+
+    def link_container_sanitized?
+      if type.allowed_in_link?
+        children.all?(&:link_containers_sanitized?)
+      else
+        false
+      end
+    end
+
+  end
+end

data/lib/slacken/document_component/sanitize_special_tag_containers.rb

@@ -0,0 +1,102 @@
+class Slacken::DocumentComponent
+  module SanitizeSpecialTagContainers
+    # Private: Sanitize not allowed tags in list, headline, and table.
+    def sanitize_special_tag_containers
+      # NOTE: each special tag (list, headline, and table) is not allowed to occur
+      #       in another type special tags.
+      case type.name
+      when /h\d/
+        derive(children.map(&:sanitize_headline))
+      when :ul, :ol, :dl
+        derive(children.map(&:sanitize_list))
+      when :table
+        derive(children.map(&:sanitize_table))
+      else
+        derive(children.map(&:sanitize_special_tag_containers))
+      end
+    end
+
+    def sanitize_headline
+      if type.allowed_in_headline?
+        derive(children.map(&:sanitize_headline))
+      else
+        # No block tags are allowed.
+        derive(children.map(&:sanitize_headline), type: :span)
+      end
+    end
+
+    def sanitize_list
+      if type.member_of?(:li, :dd)
+          head, *tails = children
+          derive([head.sanitize_list_item, *tails.map(&:sanitize_list)])
+      elsif type.allowed_in_list?
+        derive(children.map(&:sanitize_list))
+      else
+        derive(children.map(&:sanitize_list), type: block? ? :div : :span)
+      end
+    end
+
+    def sanitize_list_item
+      if type.allowed_as_list_item?
+        derive(children.map(&:sanitize_list_item))
+      else
+        # No block tags are allowed.
+        derive(children.map(&:sanitize_list_item), type: :span)
+      end
+    end
+
+    def sanitize_table
+      if type.allowed_in_table?
+        derive(children.map(&:sanitize_table))
+      else
+        # No block tags are allowed.
+        derive(children.map(&:sanitize_table), type: :span)
+      end
+    end
+
+    def sanitized?
+      case type.name
+      when /h\d/
+        children.all?(&:headline_sanitized?)
+      when :ul, :ol, :dl
+        children.all?(&:list_sanitized?)
+      when :table
+        children.all?(&:table_sanitized?)
+      else
+        children.all?(&:sanitized?)
+      end
+    end
+
+    def headline_sanitized?
+      if type.allowed_in_headline?
+        children.all?(&:headline_sanitized?)
+      else
+        false
+      end
+    end
+
+    def list_sanitized?
+      if type.allowed_in_list?
+        children.all?(&:list_sanitized?)
+      else
+        false
+      end
+    end
+
+    def list_item_sanitized?
+      if type.allowed_as_list_item?
+        children.all?(&:list_item_sanitized?)
+      else
+        false
+      end
+    end
+
+    def table_sanitized?
+      if type.allowed_in_table?
+        children.all?(&:table_sanitized?)
+      else
+        false
+      end
+    end
+  end
+end