article_json 0.1.0

data/lib/article_json/export/html/elements/base.rb

@@ -0,0 +1,59 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        class Base
+          # @param [ArticleJSON::Elements::Base] element
+          def initialize(element)
+            @element = element
+          end
+
+          # Export a HTML node out of the given element
+          # Dynamically looks up the right export-element-class, instantiates it
+          # and then calls the #build method.
+          # @return [Nokogiri::HTML::Node]
+          def export
+            exporter = self.class == Base ? self.class.build(@element) : self
+            exporter.export unless exporter.nil?
+          end
+
+          private
+
+          def create_element(tag, *args)
+            Nokogiri::HTML.fragment('').document.create_element(tag.to_s, *args)
+          end
+
+          def create_text_node(text)
+            Nokogiri::HTML.fragment(text).children.first
+          end
+
+          class << self
+            # Instantiate the correct sub class for a given element
+            # @param [ArticleJSON::Elements::Base] element
+            # @return [ArticleJSON::Export::HTML::Elements::Base]
+            def build(element)
+              klass = exporter_by_type(element.type)
+              klass.new(element) unless klass.nil?
+            end
+
+            # Look up the correct exporter class based on the element type
+            # @param [Symbol] type
+            # @return [ArticleJSON::Export::HTML::Elements::Base]
+            def exporter_by_type(type)
+              {
+                text: Text,
+                paragraph: Paragraph,
+                heading: Heading,
+                list: List,
+                image: Image,
+                text_box: TextBox,
+                quote: Quote,
+                embed: Embed,
+              }[type.to_sym]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/embed.rb

@@ -0,0 +1,28 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        class Embed < Base
+          include Shared::Caption
+
+          def export
+            create_element(:figure).tap do |figure|
+              figure.add_child(embed_node)
+              figure.add_child(caption_node(:figcaption))
+            end
+          end
+
+          private
+
+          def embed_node
+            create_element(:div, embedded_object, class: 'embed')
+          end
+
+          def embedded_object
+            "Embedded Object: #{@element.embed_type}-#{@element.embed_id}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/heading.rb

@@ -0,0 +1,19 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        class Heading < Base
+          def export
+            create_element(tag_name, @element.content)
+          end
+
+          private
+
+          def tag_name
+            "h#{@element.level}".to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/image.rb

@@ -0,0 +1,33 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        class Image < Base
+          include Shared::Caption
+          include Shared::Float
+
+          # @return [Nokogiri::HTML::Node]
+          def export
+            create_element(:figure, node_opts).tap do |figure|
+              figure.add_child(image_node)
+              figure.add_child(caption_node(:figcaption))
+            end
+          end
+
+          private
+
+          # @return [Nokogiri::HTML::Node]
+          def image_node
+            create_element(:img, src: @element.source_url)
+          end
+
+          # @return [Hash]
+          def node_opts
+            return if floating_class.nil?
+            { class: floating_class }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/list.rb

@@ -0,0 +1,25 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        class List < Base
+          def export
+            create_element(tag_name).tap do |list|
+              @element.content.each do |child_element|
+                item = create_element(:li)
+                item.add_child(Paragraph.new(child_element).export)
+                list.add_child(item)
+              end
+            end
+          end
+
+          private
+
+          def tag_name
+            @element.list_type == :ordered ? :ol : :ul
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/paragraph.rb

@@ -0,0 +1,17 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        class Paragraph < Base
+          def export
+            create_element(:p).tap do |p|
+              @element.content.each do |child_element|
+                p.add_child(Text.new(child_element).export)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/quote.rb

@@ -0,0 +1,29 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        class Quote < Base
+          include Shared::Caption
+          include Shared::Float
+
+          def export
+            create_element(:aside, node_opts).tap do |aside|
+              @element.content.each do |child_element|
+                aside.add_child(Base.new(child_element).export)
+              end
+              aside.add_child(caption_node(:small))
+            end
+          end
+
+          private
+
+          # @return [Hash]
+          def node_opts
+            return if floating_class.nil?
+            { class: floating_class }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/shared/caption.rb

@@ -0,0 +1,22 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        module Shared
+          module Caption
+            # Generate the caption node
+            # @param [String] tag_name
+            # @return [Nokogiri::HTML::Node]
+            def caption_node(tag_name)
+              create_element(tag_name).tap do |caption|
+                @element.caption.each do |child_element|
+                  caption.add_child(Text.new(child_element).export)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/shared/float.rb

@@ -0,0 +1,17 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        module Shared
+          module Float
+            # The element's floating class, if necessary
+            # @return [String]
+            def floating_class
+              "float-#{@element.float}" unless @element.float.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/text.rb

@@ -0,0 +1,44 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        class Text < Base
+          # @return [Nokogiri::HTML::Node]
+          def export
+            return bold_and_italic_node if @element.bold && @element.italic
+            return bold_node if @element.bold
+            return italic_node if @element.italic
+            content_node
+          end
+
+          private
+
+          # @return [Nokogiri::HTML::Node]
+          def italic_node
+            create_element(:em).tap { |em| em.add_child(content_node) }
+          end
+
+          # @return [Nokogiri::HTML::Node]
+          def bold_node
+            create_element(:strong).tap do |strong|
+              strong.add_child(content_node)
+            end
+          end
+
+          # @return [Nokogiri::HTML::Node]
+          def bold_and_italic_node
+            create_element(:strong).tap do |strong|
+              strong.add_child(italic_node)
+            end
+          end
+
+          # @return [Nokogiri::HTML::Node]
+          def content_node
+            return create_text_node(@element.content) if @element.href.nil?
+            create_element(:a, @element.content, href: @element.href)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/elements/text_box.rb

@@ -0,0 +1,25 @@
+module ArticleJSON
+  module Export
+    module HTML
+      module Elements
+        class TextBox < Base
+          include Shared::Float
+
+          def export
+            create_element(:div, node_opts).tap do |div|
+              @element.content.each do |child_element|
+                div.add_child(Base.new(child_element).export)
+              end
+            end
+          end
+
+          private
+
+          def node_opts
+            { class: ['text-box', floating_class].compact.join(' ') }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/export/html/exporter.rb

@@ -0,0 +1,22 @@
+module ArticleJSON
+  module Export
+    module HTML
+      class Exporter
+        # @param [Array[ArticleJSON::Elements::Base]] elements
+        def initialize(elements)
+          @elements = elements
+        end
+
+        # Generate a string with the HTML representation of all elements
+        # @return [String]
+        def html
+          doc = Nokogiri::HTML.fragment('')
+          @elements.each do |element|
+            doc.add_child(Elements::Base.new(element).export)
+          end
+          doc.to_html(save_with: 0)
+        end
+      end
+    end
+  end
+end

data/lib/article_json/import/google_doc/html/css_analyzer.rb

@@ -0,0 +1,144 @@
+module ArticleJSON
+  module Import
+    module GoogleDoc
+      module HTML
+        class CSSAnalyzer
+          attr_reader :css_parser,
+                      :bold_classes,
+                      :italic_classes,
+                      :centered_classes,
+                      :right_aligned_classes
+
+          # Initialize the parser with CSS code
+          # @param [String] css
+          def initialize(css = '')
+            @css_parser = ::CssParser::Parser.new
+            css_parser.load_string!(css)
+            parse
+          end
+
+          # Check if a given class attribute contains at least one class that
+          # makes its text bold
+          # @param [String] class_str
+          # @return [Boolean]
+          def bold?(class_str)
+            (class_str.split(' ') & bold_classes).any?
+          end
+
+          # Check if a given class attribute contains at least one class that
+          # makes its text italic
+          # @param [String] class_str
+          # @return [Boolean]
+          def italic?(class_str)
+            (class_str.split(' ') & italic_classes).any?
+          end
+
+          # Check if a given class attribute contains at least one class that
+          # sets its alignment to the right
+          # @param [String] class_str
+          # @return [Boolean]
+          def right_aligned?(class_str)
+            (class_str.split(' ') & right_aligned_classes).any?
+          end
+
+          # Check if a given class attribute contains no class that sets its
+          # alignment to right or center
+          # @param [String] class_str
+          # @return [Boolean]
+          def left_aligned?(class_str)
+            !right_aligned?(class_str) && !centered?(class_str)
+          end
+
+          # Check if a given class attribute contains at least one class that
+          # centers it
+          # @param [String] class_str
+          # @return [Boolean]
+          def centered?(class_str)
+            (class_str.split(' ') & centered_classes).any?
+          end
+
+          private
+
+          # Parse the CSS code and save CSS selectors for certain styles
+          def parse
+            # arrays containing class names for certain formatting
+            @bold_classes = []
+            @italic_classes = []
+            @right_aligned_classes = []
+            @centered_classes = []
+
+            css_parser.each_rule_set do |rule_set|
+              # does this ruleset make text bold?
+              if rule_set_is_bold?(rule_set)
+                add_classes(rule_set, bold_classes)
+              end
+              # does this ruleset make text italic?
+              if rule_set_is_italic?(rule_set)
+                add_classes(rule_set, italic_classes)
+              end
+              # does this ruleset make text right-aligned?
+              if rule_set_is_right_aligned?(rule_set)
+                add_classes(rule_set, right_aligned_classes)
+              end
+              # does this ruleset make text centered?
+              if rule_set_is_centered?(rule_set)
+                add_classes(rule_set, centered_classes)
+              end
+            end
+          end
+
+          # @param [CssParser::RuleSet] rule_set
+          # @return [Boolean]
+          def rule_set_is_bold?(rule_set)
+            value = clean_value_from_rule_set(rule_set, 'font-weight')
+            value =~ /\d/ ? value.to_i >= 600 : %w(bold bolder).include?(value)
+          end
+
+          # @param [CssParser::RuleSet] rule_set
+          # @return [Boolean]
+          def rule_set_is_italic?(rule_set)
+            clean_value_from_rule_set(rule_set, 'font-style') == 'italic'
+          end
+
+          # @param [CssParser::RuleSet] rule_set
+          # @return [Boolean]
+          def rule_set_is_right_aligned?(rule_set)
+            clean_value_from_rule_set(rule_set, 'text-align') == 'right'
+          end
+
+          # @param [CssParser::RuleSet] rule_set
+          # @return [Boolean]
+          def rule_set_is_centered?(rule_set)
+            clean_value_from_rule_set(rule_set, 'text-align') == 'center'
+          end
+
+          # @param [CssParser::RuleSet] rule_set
+          # @param [String] key
+          # @return [String]
+          def clean_value_from_rule_set(rule_set, key)
+            rule_set
+              .get_value(key)
+              .to_s
+              .tr(';', '')
+              .strip
+          end
+
+          # Add all class selectors of a rule set to a given array
+          # @param [CssParser::RuleSet] rule_set
+          # @param [Array] class_array
+          def add_classes(rule_set, class_array)
+            rule_set.each_selector do |selector|
+              selector_name = selector.to_s.strip
+              if selector_name[0] == '.'
+                selector_name = selector_name[1, selector_name.length]
+                unless class_array.include?(selector_name)
+                  class_array << selector_name
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/import/google_doc/html/embedded_facebook_video_parser.rb

@@ -0,0 +1,33 @@
+module ArticleJSON
+  module Import
+    module GoogleDoc
+      module HTML
+        class EmbeddedFacebookVideoParser < EmbeddedParser
+          # The type of this embedded element
+          # @return [Symbol]
+          def embed_type
+            :facebook_video
+          end
+
+          class << self
+            # Regular expression to check if a given string is a FB Video URL
+            # Also used to extract the ID from the URL
+            # @return [Regexp]
+            def url_regexp
+              %r{
+                ^\S*                        # all protocols & sub domains
+                facebook\.com/              # domain
+                (                           # optional path & parameters
+                  \w+/videos/|
+                  video\.php\?v=|
+                  video\.php\?id=
+                )
+                (?<id>\d+)                  # numeric video id
+              }xi
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/import/google_doc/html/embedded_parser.rb

@@ -0,0 +1,113 @@
+module ArticleJSON
+  module Import
+    module GoogleDoc
+      module HTML
+        class EmbeddedParser
+          include Shared::Caption
+
+          # @param [Nokogiri::HTML::Node] node
+          # @param [Nokogiri::HTML::Node] caption_node
+          # @param [ArticleJSON::Import::GoogleDoc::HTML::CSSAnalyzer] css_analyzer
+          def initialize(node:, caption_node:, css_analyzer:)
+            @node = node
+            @caption_node = caption_node
+            @css_analyzer = css_analyzer
+          end
+
+          # Extract the video ID from an URL
+          # @return [String]
+          def embed_id
+            match = @node.inner_text.strip.match(self.class.url_regexp)
+            match[:id] if match
+          end
+
+          # The type of this embedded element
+          # To be implemented by sub classes!
+          # @return [Symbol]
+          def embed_type
+            raise NotImplementedError
+          end
+
+          # Extract any potential tags, specified in brackets after the URL
+          # @return [Array[Symbol]]
+          def tags
+            match = /(.*?)[\s\u00A0]+\[(?<tags>.*)\]/.match(@node.inner_text)
+            (match ? match[:tags] : '').split(' ')
+          end
+
+          # The embedded element
+          # @return [ArticleJSON::Elements::Embed]
+          def element
+            ArticleJSON::Elements::Embed.new(
+              embed_type: embed_type,
+              embed_id: embed_id,
+              tags: tags,
+              caption: caption
+            )
+          end
+
+          class << self
+            # Check if a given string is a Youtube embedding
+            # @param [String] text
+            # @return [Boolean]
+            def matches?(text)
+              !!(url_regexp =~ text)
+            end
+
+            # Regular expression to check if node content is embeddable element
+            # Is also used to extract the ID from the URL.
+            # @return [Regexp]
+            def url_regexp
+              raise NotImplementedError
+            end
+
+            # Build a embedded element based on the node's content
+            # @param [Nokogiri::HTML::Node] node
+            # @param [Nokogiri::HTML::Node] caption_node
+            # @param [ArticleJSON::Import::GoogleDoc::HTML::CSSAnalyzer] css_analyzer
+            # @return [ArticleJSON::Elements::Embed]
+            def build(node:, caption_node:, css_analyzer:)
+              find_parser(node.inner_text)
+                &.new(
+                  node: node,
+                  caption_node: caption_node,
+                  css_analyzer: css_analyzer
+                )
+                &.element
+            end
+
+            # Check if a node contains a supported embedded element
+            # @param [Nokogiri::HTML::Node] node
+            # @return [Boolean]
+            def supported?(node)
+              !find_parser(node.inner_text).nil?
+            end
+
+            private
+
+            # List of embedded element classes
+            # @return [ArticleJSON::Import::GoogleDoc::HTML::EmbeddedParser]
+            def parsers
+              [
+                EmbeddedFacebookVideoParser,
+                EmbeddedVimeoVideoParser,
+                EmbeddedYoutubeVideoParser,
+                EmbeddedTweetParser,
+                EmbeddedSlideshareParser,
+              ]
+            end
+
+            # Find the first matching class for a given (URL) string
+            # @param [String] text
+            # @return [Class]
+            def find_parser(text)
+              text = text.strip.downcase
+              return nil if text.empty?
+              parsers.find { |klass| klass.matches?(text) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/article_json/import/google_doc/html/embedded_slideshare_parser.rb

@@ -0,0 +1,36 @@
+module ArticleJSON
+  module Import
+    module GoogleDoc
+      module HTML
+        class EmbeddedSlideshareParser < EmbeddedParser
+          # The type of this embedded element
+          # @return [Symbol]
+          def embed_type
+            :slideshare
+          end
+
+          # Extract the slide show ID (including the handle) from an URL
+          # @return [String]
+          def embed_id
+            match = @node.inner_text.strip.match(self.class.url_regexp)
+            "#{match[:handle]}/#{match[:id]}" if match
+          end
+
+          class << self
+            # Regular expression to check if a given string is a Slideshare URL
+            # Also used to extract HANDLE and ID from the URL.
+            # @return [Regexp]
+            def url_regexp
+              %r{
+                ^\S*                    # all protocols & sub domains
+                slideshare\.net/        # domain
+                (?<handle>[^/\s]+)/     # username / handle
+                (?<id>[^/?&\s\u00A0]+)  # the id / slug of the slide show
+              }xi
+            end
+          end
+        end
+      end
+    end
+  end
+end