infoboxer 0.1.0

data/lib/infoboxer/navigation/sections.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+module Infoboxer
+  module Navigation
+    # `Sections` module provides logical view on document strcture.
+    #
+    # From this module's point of view, each {Tree::Document Document} is a
+    # {Sections::Container Sections::Container}, which consists of
+    # {Sections::Container#intro} (before first heading) and a set of
+    # nested {Sections::Container#sections}.
+    #
+    # Each document node, in turn, provides method {Sections::Node#in_sections},
+    # allowing you to receive list of sections, which contains current
+    # node.
+    #
+    # **NB**: Sections are "virtual" nodes, they are not, in fact, in
+    # documents tree. So, you can be surprised with:
+    #
+    # ```ruby
+    # document.sections         # => list of Section instances
+    # document.lookup(:Section) # => []
+    #
+    # paragraph.in_sections     # => list of sections
+    # paragraph.
+    #  lookup_parents(:Section) # => []
+    # ```
+    module Sections
+      # This module is included in {Tree::Document Document}, allowing 
+      # you to navigate through document's logical sections (and also
+      # included in each {Sections::Section} instance, allowing to navigate
+      # recursively).
+      #
+      # See also {Sections parent module} docs.
+      module Container
+        # All container's paragraph-level nodes before first heading.
+        #
+        # @return {Tree::Nodes}
+        def intro
+          children.
+            take_while{|n| !n.is_a?(Tree::Heading)}.
+            select{|n| n.is_a?(Tree::BaseParagraph)}
+        end
+
+        # List of sections inside current container.
+        #
+        # Examples of usage:
+        #
+        # ```ruby
+        # document.sections                 # all top-level sections
+        # document.sections('Culture')      # only "Culture" section
+        # document.sections(/^List of/)     # all sections with heading matching pattern
+        #   
+        # document.   
+        #   sections('Culture').            # long way of recieve nested section
+        #     sections('Music')             # (Culture / Music)
+        # 
+        # document. 
+        #   sections('Culture', 'Music')    # the same as above
+        #
+        # document.
+        #   sections('Culture' => 'Music')  # pretty-looking version for 2 levels of nesting
+        # ```
+        #
+        # @return {Tree::Nodes<Section>}
+        def sections(*names)
+          @sections ||= make_sections
+
+          if names.first.is_a?(Hash)
+            h = names.shift
+            h.count == 1 or fail(ArgumentError, "Undefined behavior with #{h}")
+            names.unshift(h.keys.first, h.values.first)
+          end
+          
+          case names.count
+          when 0
+            @sections
+          when 1
+            @sections.select{|s| names.first === s.heading.text_}
+          else
+            @sections.select{|s| names.first === s.heading.text_}.sections(*names[1..-1])
+          end
+        end
+
+        private
+
+        def make_sections
+          res = Tree::Nodes[]
+          return res if headings.empty?
+          level = headings.first.level
+
+          children.
+            chunk{|n| n.matches?(Tree::Heading, level: level)}.
+            drop_while{|is_heading, nodes| !is_heading}.
+            each do |is_heading, nodes|
+              if is_heading
+                nodes.each do |node|
+                  res << Section.new(node)
+                end
+              else
+                res.last.push_children(*nodes)
+              end
+            end
+
+          res
+        end
+      end
+
+      # Part of {Sections} navigation, allowing each node to know exact
+      # list of sections it contained in.
+      #
+      # See also {Sections parent module} documentation.
+      module Node
+        # List of sections current node contained in (bottom-to-top:
+        # smallest section first).
+        #
+        # @return {Tree::Nodes<Section>}
+        def in_sections
+          main_node = parent.is_a?(Tree::Document) ? self : lookup_parents[-2]
+          
+          heading = if main_node.is_a?(Tree::Heading)
+            main_node.lookup_prev_siblings(Tree::Heading, level: main_node.level - 1).last
+          else
+            main_node.lookup_prev_siblings(Tree::Heading).last
+          end
+          return Tree::Nodes[] unless heading
+          
+          section = Section.new(heading,
+            heading.next_siblings.
+              take_while{|n| !n.is_a?(Tree::Heading) || n.level < heading.level}
+          )
+          Tree::Nodes[section, *heading.in_sections]
+        end
+      end
+
+      # Part of {Sections} navigation, allowing chains of section search.
+      #
+      # See {Sections parent module} documentation.
+      module Nodes
+        # @!method sections(*names)
+        # @!method in_sections
+        
+        [:sections, :in_sections].each do |sym|
+          define_method(sym){|*args|
+            make_nodes map{|n| n.send(sym, *args)}
+          }
+        end
+      end
+
+      # Virtual node, representing logical section of the document.
+      # Is not, in fact, in the tree.
+      #
+      # See {Sections parent module} documentation for details.
+      class Section < Tree::Compound
+        def initialize(heading, children = Tree::Nodes[])
+          # no super: we don't wont to rewriter children's parent
+          @children = Tree::Nodes[*children]
+          @heading = heading
+        end
+
+        # Section's heading.
+        #
+        # @return {Tree::Heading}
+        attr_reader :heading
+
+        # no rewriting of parent, again
+        def push_children(*nodes)
+          nodes.each do |n|
+            @children << n
+          end
+        end
+
+        def empty?
+          false
+        end
+
+        include Container
+      end
+    end
+  end
+end

data/lib/infoboxer/navigation/selector.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Infoboxer
+  module Navigation
+    module Lookup
+      # Incapsulates storage of selectors, used in {Lookup::Node node lookup}.
+      #
+      # See {Lookup::Node Lookup::Node} for detailed explanation of available selectors.
+      class Selector
+        include ProcMe
+        
+        def initialize(*arg, &block)
+          @arg = [arg, block].flatten.compact.map(&method(:sym_to_class))
+          @arg.each do |a|
+            a.reject!{|k, v| v.nil?} if a.is_a?(Hash)
+          end
+        end
+
+        attr_reader :arg
+
+        def ==(other)
+          self.class == other.class && arg == other.arg
+        end
+
+        def inspect
+          "#<Selector(#{@arg.map(&:to_s).join(', ')})>"
+        end
+
+        def matches?(node)
+          @arg.all?{|a| arg_matches?(a, node)}
+        end
+
+        private
+
+        def sym_to_class(a)
+          if a.is_a?(Symbol) && a =~ /^[A-Z][a-zA-Z]+$/ && Tree.const_defined?(a)
+            Tree.const_get(a)
+          else
+            a
+          end
+        end
+
+        def arg_matches?(check, node)
+          case check
+          when Proc
+            check.call(node)
+          when Hash
+            check.all?{|attr, value|
+              node.respond_to?(attr) && value === node.send(attr)
+            }
+          when Symbol
+            node.respond_to?(check) && node.send(check)
+          else
+            check === node
+          end
+        end
+      end
+    end
+  end
+end

data/lib/infoboxer/navigation/shortcuts.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+module Infoboxer
+  module Navigation
+    # See {Shortcuts::Node Shortcuts::Node} for everything!
+    module Shortcuts
+      # `Shortcuts::Node` module provides some convenience methods for
+      # most used lookups. It's not a rocket science (as you can see
+      # from methods code), yet should make your code cleaner and
+      # more readable.
+      #
+      # **NB**: as usual, {Tree::Nodes} class have synonyms for all of
+      # those methods, so you can call them fearlessly on any results of
+      # node lookup.
+      #
+      module Node
+        # Returns all wikilinks inside current node.
+        #
+        # @param namespace from which namespace links do you want. It's
+        #   `''` (main namespace only) by default, if you really want all
+        #   wikilinks on the page, including categories, interwikies and
+        #   stuff, use `wikilinks(nil)`
+        # @return {Tree::Nodes}
+        def wikilinks(namespace = '')
+          lookup(Tree::Wikilink, namespace: namespace)
+        end
+
+        # Returns all headings inside current node.
+        #
+        # @param level headings level to return.
+        # @return {Tree::Nodes}
+        def headings(level = nil)
+          lookup(Tree::Heading, level: level)
+        end
+
+        # Returns all paragraph-level nodes (list items, plain paragraphs,
+        # headings and so on) inside current node.
+        #
+        # @param selectors node selectors, as described at {Lookup::Node}
+        # @return {Tree::Nodes}
+        def paragraphs(*selectors, &block)
+          lookup(Tree::BaseParagraph, *selectors, &block)
+        end
+
+        # Returns all external links inside current node.
+        #
+        # @param selectors node selectors, as described at {Lookup::Node}
+        # @return {Tree::Nodes}
+        def external_links(*selectors, &block)
+          lookup(Tree::ExternalLink, *selectors, &block)
+        end
+
+        # Returns all images (media) inside current node.
+        #
+        # @param selectors node selectors, as described at {Lookup::Node}
+        # @return {Tree::Nodes}
+        def images(*selectors, &block)
+          lookup(Tree::Image, *selectors, &block)
+        end
+
+        # Returns all templates inside current node.
+        #
+        # @param selectors node selectors, as described at {Lookup::Node}
+        # @return {Tree::Nodes}
+        def templates(*selectors, &block)
+          lookup(Tree::Template, *selectors, &block)
+        end
+
+        # Returns all tables inside current node.
+        #
+        # @param selectors node selectors, as described at {Lookup::Node}
+        # @return {Tree::Nodes}
+        def tables(*selectors, &block)
+          lookup(Tree::Table, *selectors, &block)
+        end
+
+        # Returns all lists (ordered/unordered/definition) inside current node.
+        #
+        # @param selectors node selectors, as described at {Lookup::Node}
+        # @return {Tree::Nodes}
+        def lists(*selectors, &block)
+          lookup(Tree::List, *selectors, &block)
+        end
+
+        # Returns true, if current node is **inside** bold.
+        def bold?
+          has_parent?(Tree::Bold)
+        end
+
+        # Returns true, if current node is **inside** italic.
+        def italic?
+          has_parent?(Tree::Italic)
+        end
+
+        # Returns true, if current node is **inside** heading.
+        #
+        # @param level optional concrete level to check
+        def heading?(level = nil)
+          has_parent?(Tree::Heading, level: level)
+        end
+
+        # Returns all infoboxes inside current node.
+        #
+        # Definition of what considered to be infobox depends on templates
+        # set used when parsing the page.
+        #
+        # @param selectors node selectors, as described at {Lookup::Node}
+        # @return {Tree::Nodes}
+        def infoboxes(*selectors, &block)
+          lookup(Tree::Template, :infobox?, *selectors, &block)
+        end
+
+        # Returns all wikilinks in "categories namespace".
+        #
+        # **NB**: depending on your MediaWiki settings, name of categories
+        # namespace may vary. When you are using {MediaWiki#get}, Infoboxer
+        # tries to handle this transparently (by examining used wiki for
+        # category names), yet bad things may happen here.
+        #
+        # @return {Tree::Nodes}
+        def categories
+          lookup(Tree::Wikilink, namespace: /^#{ensure_traits.category_prefix.join('|')}$/)
+        end
+
+        # As users accustomed to have only one infobox on a page
+        alias_method :infobox, :infoboxes
+
+        private
+
+        def ensure_traits
+          ensure_page.traits or fail("No site traits found")
+        end
+
+        def ensure_page
+          (is_a?(MediaWiki::Page) ? self : lookup_parents(MediaWiki::Page).first) or
+            fail("Node is not inside Page, maybe parsed from text?")
+        end
+      end
+
+      # Companion module of {Shortcuts::Node Shortcuts::Node}, defining
+      # all the same methods for {Tree::Nodes} so you can use them
+      # uniformely on single node or list. See {Shortcuts::Node there} for
+      # details.
+      module Nodes
+        # @!method wikilinks(namespace = '')
+        # @!method headings(level = nil)
+        # @!method paragraphs(*selectors, &block)
+        # @!method external_links(*selectors, &block)
+        # @!method images(*selectors, &block)
+        # @!method templates(*selectors, &block)
+        # @!method tables(*selectors, &block)
+        # @!method lists(*selectors, &block)
+        # @!method infoboxes(*selectors, &block)
+        # @!method categories
+
+        [:wikilinks, :headings, :paragraphs, :external_links, :images,
+         :templates, :tables, :lists, :infoboxes, :infobox, :categories].
+          each do |m|
+            define_method(m){|*args|
+              make_nodes map{|n| n.send(m, *args)}
+            }
+          end
+      end
+    end
+  end
+end

data/lib/infoboxer/parser.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+require 'ostruct'
+require 'procme'
+
+module Infoboxer
+  class Parser
+    class ParsingError < RuntimeError
+    end
+
+    class << self
+      def inline(text, traits = nil)
+        new(context(text, traits)).inline
+      end
+
+      def paragraphs(text, traits = nil)
+        new(context(text, traits)).paragraphs
+      end
+
+      def paragraph(text, traits = nil)
+        paragraphs(text, traits).first
+      end
+
+      def document(text, traits = nil)
+        Tree::Document.new(paragraphs(text, traits))
+      end
+
+      def fragment(text, traits = nil)
+        new(context(text, traits)).long_inline
+      end
+
+      private
+
+      def context(text, traits)
+        Context.new(text, coerce_traits(traits))
+      end
+
+      def coerce_traits(traits)
+        case traits
+        when nil
+          MediaWiki::Traits.default
+        when Hash
+          MediaWiki::Traits.new(traits)
+        when MediaWiki::Traits
+          traits
+        else
+          fail(ArgumentError, "Can't coerce site traits from #{traits.inspect}")
+        end
+      end
+    end
+    
+    include Tree
+
+    def initialize(context)
+      @context = context
+      @re = OpenStruct.new(make_regexps)
+    end
+
+    require_relative 'parser/inline'
+    include Parser::Inline
+
+    require_relative 'parser/paragraphs'
+    include Parser::Paragraphs
+
+    private
+
+    require_relative 'parser/util'
+    include Parser::Util
+  end
+end
+
+require_relative 'parser/context'