wiki-api 0.1.0 → 0.1.2

data/lib/wiki/api/page_block.rb

@@ -1,27 +1,28 @@
+# frozen_string_literal: true
+
 module Wiki
   module Api
-
     # Collection of elements for segmented per headline
     class PageBlock
-
       attr_accessor :elements, :parent
 
-      def initialize options={}
-        self.parent = options[:parent] if options.include? :parent
+      def initialize(options = {})
+        self.parent = options[:parent] if options.include?(:parent)
         self.elements = []
       end
 
-      def << value
+      def <<(value)
         # value.first.previous.name
-        self.elements << value
+        elements << value
       end
 
       def to_texts
         texts = []
-        self.elements.flatten.each do |element|
-          text = Wiki::Api::Util.element_to_text element if element.is_a? Nokogiri::XML::Element
+        elements.flatten.each do |element|
+          text = Wiki::Api::Util.element_to_text(element) if element.is_a?(Nokogiri::XML::Element)
           next if text.nil?
           next if text.empty?
+
           texts << text
         end
         texts
@@ -29,27 +30,25 @@ module Wiki
 
       def list_items
         # TODO: perhaps we should wrap the elements with objects, and request a li per element??
-        self.search("li").map do |list_item|
-          PageListItem.new parent: self, element: list_item
+        search('li').map do |list_item|
+          PageListItem.new(parent: self, element: list_item)
         end
       end
 
       def links
         # TODO: perhaps we should wrap the elements with objects, and request a li per element??
-        self.search("a").map do |a|
-          PageLink.new parent: self, element: a
+        search('a').map do |a|
+          PageLink.new(parent: self, element: a)
         end
       end
 
       protected
 
       def search *paths
-        self.elements.flatten.flat_map do |element|
+        elements.flatten.flat_map do |element|
           element.search(*paths)
-        end.reject{|t| t.nil?}
+        end.reject(&:nil?)
       end
-
     end
-
   end
-end
+end

data/lib/wiki/api/page_headline.rb

@@ -1,117 +1,118 @@
+# frozen_string_literal: true
+
 module Wiki
   module Api
-
     # Headline for a page (class="mw-healine")
     class PageHeadline
-
       require 'json'
 
-      LEVEL = ["text", "h1", "h2", "h3", "h4", "h5", "h6"]
+      LEVEL = %w[text h1 h2 h3 h4 h5 h6].freeze
 
       attr_accessor :name, :block, :parent, :headlines, :level
 
-      def initialize options={}
-        self.name = options[:name] if options.include? :name
-        self.parent = options[:parent] if options.include? :parent
-        self.level = options[:level] if options.include? :level
+      def initialize(options = {})
+        self.name = options[:name] if options.include?(:name)
+        self.parent = options[:parent] if options.include?(:parent)
+        self.level = options[:level] if options.include?(:level)
         options[:headlines] ||= []
         self.headlines ||= {}
 
         # store elements in a block
-        self.block = PageBlock.new parent: self
-        if options[:headlines].include? self.name
-          options[:headlines][self.name].each do |element|
-            self.block << element
+        self.block = PageBlock.new(parent: self)
+        if options[:headlines].include?(name)
+          options[:headlines][name].each do |element|
+            block << element
           end
         end
 
         # collect nested headlines
         headlines = options[:headlines]
         # remove self from list
-        headlines.delete self.name
-        nested_headlines = self.nested_headlines headlines, self.name, self.level
+        headlines.delete(name)
+        nested_headlines = self.nested_headlines(headlines, name, level)
 
         # iterate nested headlines, and call recursive
         nested_headlines.each do |headline_name, value|
-          level = LEVEL.index value.first.first.previous.name
-          self.headlines[headline_name] = (PageHeadline.new parent: self, name: headline_name, headlines: headlines, level: level)
+          level = LEVEL.index(value.first.first.previous.name)
+          self.headlines[headline_name] =
+            PageHeadline.new(parent: self, name: headline_name, headlines:, level:)
         end
       end
 
       def elements
-        self.block.elements
+        block.elements
       end
 
       def type
-        self.block.elements.first.first.previous.name
+        block.elements.first.first.previous.name
       end
 
       # get headline by name
-      def headline name
-        name = name.downcase.gsub(" ", "_")
-        self.headlines.reject do |k,v| 
-          !k.downcase.start_with?(name)
-        end.values()
+      def headline(name)
+        name = name.downcase.gsub(' ', '_')
+        self.headlines.select do |k, _v|
+          k.downcase.start_with?(name)
+        end.values
       end
 
-      # recursive headline search
-      # def headline_by_name name, depth = 1
-      #   name = name.downcase.gsub(" ", "_")
-      #   ret = []
-      #   self.headlines.each do |k,v|
-      #     ret << v if k.downcase.start_with?(name)
-      #     next if v.headlines.empty?
-      #     if depth > 0
-      #       q = v.headline_by_name name, (depth - 1)
-      #       ret.concat q
-      #     end
-      #   end
-      #   ret
-      # end
+      def headline_in_depth(name, depth = 1)
+        name = name.downcase.gsub(' ', '_')
+        ret = []
+
+        self.headlines.each do |k, v|
+          ret << v if k.downcase.start_with?(name)
+          next if v.headlines.empty?
+
+          if depth.positive?
+            q = v.headline_in_depth(name, (depth - 1))
+            ret.concat(q)
+          end
+        end
+        ret
+      end
 
       # headline exists for current headline
-      def has_headline? name
-        name = name.downcase.gsub(" ", "_")
-        self.headlines.each do |k,v|
+      def has_headline?(name)
+        name = name.downcase.gsub(' ', '_')
+        self.headlines.each_key do |k|
           return true if k.downcase.start_with?(name)
         end
         false
       end
 
       def to_hash
-        ret = {name: self.name, headlines: [], type: self.type}
-        self.headlines.each do |headline_name, headline|
+        ret = { name:, headlines: [], type: }
+        self.headlines.each_value do |headline|
           ret[:headlines] << headline.to_hash
         end
         ret
       end
 
       def to_pretty_json
-        JSON.pretty_generate self.to_hash
+        JSON.pretty_generate(to_hash)
       end
 
-      protected 
+      protected
 
       # filter nested headlines (elements) from a parent headline (by name)
-      def nested_headlines headlines, name, original_level
+      def nested_headlines(headlines, _name, original_level)
         ret = {}
         init_level = nil
         # iterate headlines, skip already done onces
-        #headlines.drop(headline_index + 1).each do |headline|
+        # headlines.drop(headline_index + 1).each do |headline|
         headlines.to_a.each do |name, value|
-          level = LEVEL.index value.first.first.previous.name
-          init_level ||= level          
+          level = LEVEL.index(value.first.first.previous.name)
+          init_level ||= level
           # lower level indicate nest end
           break if level <= original_level
           break if level < init_level
           # higher level indicates nested items, these will be processed recursive
           next if init_level != level
+
           ret[name] = value
         end
         ret
       end
-
     end
-
   end
-end
+end

data/lib/wiki/api/page_link.rb

@@ -1,38 +1,37 @@
+# frozen_string_literal: true
+
 module Wiki
   module Api
-
     # Link on a wiki page (a href=xxx)
     class PageLink
-
       attr_accessor :element, :parent
 
-      def initialize options={}
-        self.element = options[:element] if options.include? :element
-        self.parent = options[:parent] if options.include? :parent
+      def initialize(options = {})
+        self.element = options[:element] if options.include?(:element)
+        self.parent = options[:parent] if options.include?(:parent)
       end
 
       def to_text
-        Wiki::Api::Util.element_to_text self.element
+        Wiki::Api::Util.element_to_text(element)
       end
 
       def uri
         # lookup the root parent, and get connector info
         host = Wiki::Api::Util.parent_root(self).connect.uri
-        href_value = self.element.attributes["href"].value
-        URI.parse "#{host}#{href_value}"
+        href_value = element.attributes['href'].value
+        URI.parse("#{host}#{href_value}")
       end
 
       def title
         # skip links with no title
-        return "" if self.element.attributes["title"].nil?
-        self.element.attributes["title"].value
+        return '' if element.attributes['title'].nil?
+
+        element.attributes['title'].value
       end
 
       def html
-        "<a href=\"#{self.uri}\" alt=\"#{self.title}\">#{self.title}</a>"
+        "<a href=\"#{uri}\" alt=\"#{title}\">#{title}</a>"
       end
-
     end
-
   end
-end
+end

data/lib/wiki/api/page_list_item.rb

@@ -1,34 +1,31 @@
+# frozen_string_literal: true
+
 module Wiki
   module Api
-
     # List Items on a Page (li=xxx)
     class PageListItem
-
       attr_accessor :element, :parent
 
-      def initialize options={}
-        self.element = options[:element] if options.include? :element
-        self.parent = options[:parent] if options.include? :parent
+      def initialize(options = {})
+        self.parent = options[:parent] if options.include?(:parent)
+        self.element = options[:element] if options.include?(:element)
       end
 
       def to_text
-        Wiki::Api::Util.element_to_text self.element
+        Wiki::Api::Util.element_to_text(element)
       end
 
       def links
-        self.search("a").map do |a|
-          PageLink.new parent: self, element: a
+        search('a').map do |a|
+          PageLink.new(parent: self, element: a)
         end
       end
 
       protected
 
       def search *paths
-        self.element.search(*paths)
+        element.search(*paths)
       end
-
-
     end
-
   end
-end
+end

data/lib/wiki/api/util.rb

@@ -1,46 +1,44 @@
+# frozen_string_literal: true
+
 module Wiki
   module Api
-
     class Util
-
       class << self
+        def element_to_text(element)
+          raise('not an element') unless element.is_a?(Nokogiri::XML::Element)
 
-        def element_to_text element
-          raise "not an element" unless element.is_a? Nokogiri::XML::Element
-          self.clean_text element.text
+          clean_text(element.text)
         end
 
-        def element_filter_lists element
-          raise "not an element" unless element.is_a? Nokogiri::XML::Element
+        def element_filter_lists(element)
+          raise('not an element') unless element.is_a?(Nokogiri::XML::Element)
+
           result = {}
-          element.search("li").each_with_index do |li, i|
+          element.search('li').each_with_index do |li, i|
             li.children.each do |child|
               result[i] ||= []
-              result[i] << self.clean_text(child.text)
+              result[i] << clean_text(child.text)
             end
           end
-          result.map{ |k,v| v.join("") }
+          result.map { |_k, v| v.join('') }
         end
 
-        def parent_root current_object
+        def parent_root(current_object)
           current = current_object
-          while true do
+          loop do
             break if current.parent.nil?
+
             current = current.parent
           end
           current
         end
 
-        
-
-
         protected
-        def clean_text text
-          text.gsub(/\n/, " ").squeeze(" ").gsub(/\s(\W)/, '\1').gsub(/(\W)\s/, '\1 ').strip
-        end
 
+        def clean_text(text)
+          text.gsub(/\n/, ' ').squeeze(' ').gsub(/\s(\W)/, '\1').gsub(/(\W)\s/, '\1 ').strip
+        end
       end
-
     end
   end
-end
+end

data/lib/wiki/api/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Wiki
   module Api
-    VERSION = "0.1.0"
+    VERSION = '0.1.2'
   end
 end

data/lib/wiki/api.rb

@@ -1,12 +1,13 @@
-require File.expand_path(File.dirname(__FILE__) + "/api/version")
-require File.expand_path(File.dirname(__FILE__) + "/api/connect")
-require File.expand_path(File.dirname(__FILE__) + "/api/page")
-require File.expand_path(File.dirname(__FILE__) + "/api/page_headline")
-require File.expand_path(File.dirname(__FILE__) + "/api/page_block")
-require File.expand_path(File.dirname(__FILE__) + "/api/page_list_item")
-require File.expand_path(File.dirname(__FILE__) + "/api/page_link")
-require File.expand_path(File.dirname(__FILE__) + "/api/util")
+# frozen_string_literal: true
 
+require File.expand_path("#{File.dirname(__FILE__)}/api/version")
+require File.expand_path("#{File.dirname(__FILE__)}/api/connect")
+require File.expand_path("#{File.dirname(__FILE__)}/api/page")
+require File.expand_path("#{File.dirname(__FILE__)}/api/page_headline")
+require File.expand_path("#{File.dirname(__FILE__)}/api/page_block")
+require File.expand_path("#{File.dirname(__FILE__)}/api/page_list_item")
+require File.expand_path("#{File.dirname(__FILE__)}/api/page_link")
+require File.expand_path("#{File.dirname(__FILE__)}/api/util")
 
 module Wiki
   module Api

data/test/test_helper.rb

@@ -1,8 +1,5 @@
+# frozen_string_literal: true
 
-class ActiveSupport::TestCase
-  setup :global_setup
-
-  def global_setup
-  end
-end
-
+require 'rubygems'
+require 'test/unit'
+require File.expand_path("#{File.dirname(__FILE__)}/../lib/wiki/api")

data/test/unit/wiki_connect.rb

@@ -1,51 +1,44 @@
-require 'rubygems'
-require 'test/unit'
-require File.expand_path(File.dirname(__FILE__) + "/../../lib/wiki/api")
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'pry'
 
 #
 # Testing the connection to https://www.mediawiki.org/wiki/API:Main_page
 #
 
 class WikiConnect < Test::Unit::TestCase
-
-  CONFIG = { uri: "http://en.wiktionary.org" }
+  CONFIG = { uri: 'https://en.wiktionary.org' }.freeze
 
   def setup
     Wiki::Api::Connect.config = CONFIG
   end
 
-  def teardown
-  end
+  def teardown; end
 
   def test_connection_wiktionary
-    c = Wiki::Api::Connect.new uri: "http://en.wiktionary.org"
+    c = Wiki::Api::Connect.new(uri: 'http://en.wiktionary.org')
     ret = c.connect
-    assert ret.is_a?(Net::HTTPOK), "invalid response http"
+    assert(ret.is_a?(Net::HTTPMovedPermanently), 'invalid response http')
   end
 
   def test_connection_https_wiktionary
-    c = Wiki::Api::Connect.new uri: "https://en.wiktionary.org"
+    c = Wiki::Api::Connect.new(uri: 'https://en.wiktionary.org')
     ret = c.connect
-    assert ret.is_a?(Net::HTTPOK), "invalid response https"
+    assert(ret.is_a?(Net::HTTPOK), 'invalid response https')
   end
 
   def test_page_get
-    begin
-      c = Wiki::Api::Connect.new
-      c.page "Wiktionary:Welcome,_newcomers"
-    rescue Exception => e
-      assert false, "expected valid page #{e.message}"
-    end
+    c = Wiki::Api::Connect.new
+    c.page('Wiktionary:Welcome,_newcomers')
+  rescue Exception => e
+    assert(false, "expected valid page #{e.message}")
   end
 
   def test_page_get_non_exist
-    begin
-      c = Wiki::Api::Connect.new
-      response = c.page "asfsldkfjjlkanv98yhok"
-    rescue Exception => e
-      assert (e.message == "missingtitle"), "expected invalid page #{e.message}"
-    end
+    c = Wiki::Api::Connect.new
+    c.page('asfsldkfjjlkanv98yhok')
+  rescue Exception => e
+    assert((e.message == 'missingtitle'), "expected invalid page #{e.message}")
   end
-
-
 end