reality 0.0.1

data/examples/all_countries.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift 'lib'
+require 'reality'
+require 'fileutils'
+require 'yaml'
+
+FileUtils.mkdir_p 'examples/output'
+
+start = Time.now
+
+File.write 'examples/output/countries.yaml',
+  Reality.countries.to_a.sort_by(&:name).map(&:to_h).to_yaml
+
+puts "Finished in %i seconds" % (Time.now - start)

data/lib/reality.rb

@@ -0,0 +1,15 @@
+require 'infoboxer'
+
+module Reality
+  require_relative 'reality/infoboxer_templates'
+  
+  # basic functionality
+  %w[measure].each do |mod|
+    require_relative "reality/#{mod}"
+  end
+
+  # entities
+  %w[country].each do |mod|
+    require_relative "reality/#{mod}"
+  end
+end

data/lib/reality/country.rb

@@ -0,0 +1,283 @@
+# NB: all of this is early drafts, so may look naive and sub-optimal.
+# Just stay tuned!
+
+module Reality
+  class Country
+    class List
+      def initialize(*names)
+        @names = names
+      end
+
+      def count
+        @names.count
+      end
+
+      def first(n = nil)
+        res = get(*@names.first(n || 1))
+        n ? res : res.first
+      end
+
+      def last(n = nil)
+        res = get(*@names.last(n || 1))
+        n ? res : res.first
+      end
+
+      def sample(n = nil)
+        res = get(*@names.sample(n || 1))
+        n ? res : res.first
+      end
+
+      def each(&block)
+        @pages = get(*@names)
+        @pages.each(&block)
+      end
+
+      include Enumerable
+
+      def to_a
+        get(*@names)
+      end
+
+      def where(**filters)
+        names = @names & Reality::Country.
+          by_continents.
+          select{|k, v| v == filters[:continent]}.
+          map(&:first)
+          
+        self.class.new(*names)
+      end
+
+      private
+
+      def get(*names)
+        Reality.wp.get(*names).map{|page| Country.new(page)}
+      end
+    end
+    
+    def initialize(page)
+      @page = page
+    end
+
+    def name
+      page.title
+    end
+
+    def long_name
+      infobox.fetch('conventional_long_name').text.strip
+    end
+
+    def capital
+      infobox.fetch('capital').lookup(:Wikilink).first
+    end
+
+    def languages
+      [
+        ['Official', infobox_links('official_languages')],
+        [infobox.fetch('languages_type').text.sub(/ languages?$/, ''), infobox_links('languages')]
+      ].reject{|k, v| k.empty? || v.empty?}.to_h
+    end
+
+    def tld
+      tlds.first
+    end
+
+    def tlds
+      infobox_links('cctld').map(&:link)
+    end
+
+    def calling_code
+      infobox.fetch('calling_code').text.strip
+    end
+
+    def utc_offset
+      infobox.fetch('utc_offset').text.sub('−', '-').to_i
+    end
+
+    def currency
+      currencies.first
+    end
+
+    def currencies
+      infobox_links('currency').reject{|l| l.link == 'ISO 4217'}
+    end
+
+    def area
+      Reality::Measure(infobox.fetch('area_km2').text.gsub(',', '').to_i, 'km²')
+    end
+
+    def population
+      val = %w[population_estimate population_census].map{|var|
+        infobox.fetch(var).text.strip
+      }.reject(&:empty?).first
+      val && Reality::Measure(parse_maybe_scaled(val), 'person')
+    end
+
+    def gdp_ppp
+      val = infobox.fetch('GDP_PPP').text.strip.sub(/^((Int|US)?\$|USD)/, '')
+      val.empty? ? nil : Reality::Measure(parse_scaled(val), '$')
+    end
+
+    def gdp_nominal
+      val = infobox.fetch('GDP_nominal').text.strip.sub(/^((Int|US)?\$|USD)/, '')
+      val.empty? ? nil : Reality::Measure(parse_scaled(val), '$')
+    end
+
+    alias_method :gdp, :gdp_nominal
+
+    def leaders
+      titles = infobox.fetch(/^leader_title\d/).map(&:text_)
+      names = infobox.fetch(/^leader_name\d/).map{|v| v.lookup(:Wikilink).first}
+      titles.zip(names).to_h
+    end
+
+    def continent
+      self.class.by_continents[page.title]
+    end
+
+    def organizations
+      organizations_list.map{|o| o[:name]}
+    end
+
+    def member_of?(org)
+      organizations_list.any?{|o| o[:name] == org || o[:abbr] == org}
+    end
+
+    def to_s
+      name
+    end
+
+    def inspect
+      "#<#{self.class}(#{name})>"
+    end
+
+    PROPERTIES = %i[
+                    continent name long_name
+                    tld tlds calling_code utc_offset
+                    capital languages currency
+                    leaders area population
+                    gdp_ppp gdp_nominal
+                  ]
+
+    def to_h
+      #p self
+      PROPERTIES.
+        map{|prop| [prop, to_simple_type(send(prop))]  }.
+        #reject{|prop, val| !val || val.respond_to?(:empty?) && val.empty?}.
+        to_h
+    end
+
+    class << self
+      def by_continents
+        @by_continents ||= Reality.wp.
+          get('List of countries by continent').
+          sections.first.
+          sections.map{|s|
+            continent = s.heading.text_
+            s.tables.first.
+              lookup(:Wikilink, :bold?).map(&:link).
+              map{|country| [country, continent]}
+          }.flatten(1).
+          to_h
+      end
+
+      def organizations
+        @organizations ||= YAML.load(File.read(File.expand_path('../../../data/country_orgs.yaml', __FILE__)))
+      end
+    end
+
+    private
+
+    attr_reader :page
+
+    def infobox
+      page.infobox
+    end
+
+    def organizations_list
+      catnames = page.categories.map(&:name)
+      self.class.organizations.select{|o| catnames.include?(o[:category])}
+    end
+
+    def infobox_links(varname)
+      src = infobox.fetch(varname)
+      if tmpl = src.lookup(:Template, name: /list$/).first
+        # values could be both inside and outside list, see India's cctld value
+        src = Infoboxer::Tree::Nodes[src, tmpl.variables] 
+      end
+      src.lookup(:Wikilink).uniq
+    end
+
+    # See "Short scale": https://en.wikipedia.org/wiki/Long_and_short_scales#Comparison
+    SCALES = {
+      'million'     => 1_000_000,
+      'billion'     => 1_000_000_000,
+      'trillion'    => 1_000_000_000_000,
+      'quadrillion' => 1_000_000_000_000_000,
+      'quintillion' => 1_000_000_000_000_000_000,
+      'sextillion'  => 1_000_000_000_000_000_000_000,
+      'septillion'  => 1_000_000_000_000_000_000_000_000,
+    }
+    SCALES_REGEXP = Regexp.union(*SCALES.keys)
+
+    def parse_scaled(str)
+      match, amount, scale = */^([0-9.,]+)[[:space:]]*(#{SCALES_REGEXP})/.match(str)
+      match or
+        fail(ArgumentError, "Unparseable scaled value #{str} for #{self}")
+
+      (amount.gsub(/[,]/, '').to_f * fetch_scale(scale)).to_i
+    end
+
+    def parse_maybe_scaled(str)
+      match, amount, scale = */^([0-9.,]+)[[:space:]]*(#{SCALES_REGEXP})?/.match(str)
+      match or
+        fail(ArgumentError, "Unparseable scaled value #{str} for #{self}")
+
+      if scale
+        (amount.gsub(/[,]/, '').to_f * fetch_scale(scale)).to_i
+      else
+        amount.gsub(/[,]/, '').to_i
+      end
+    end
+
+    def fetch_scale(str)
+      _, res = SCALES.detect{|key, val| str.start_with?(key)}
+
+      res or fail("Scale not found: #{str} for #{self}")
+    end
+
+    def to_simple_type(val)
+      case val
+      when nil, Numeric, String, Symbol
+        val
+      when Array
+        val.map{|v| to_simple_type(v)}
+      when Hash
+        val.map{|k, v| [to_simple_type(k), to_simple_type(v)]}.to_h
+      when Infoboxer::Tree::Wikilink
+        val.link
+      when Infoboxer::Tree::Node
+        val.text_
+      when Reality::Measure
+        val.amount
+      else
+        fail ArgumentError, "Non-coercible value #{val.class}"
+      end
+    end
+  end
+
+  def Reality.country(name)
+    page = wp.get(name) or return nil
+    # FIXME: not very reliable, as some fictional countries, aliances
+    #   and country groups also have this infobox. Or maybe it is acceptable?..
+    page.templates(name: 'Infobox country').empty? ? nil : Country.new(page)
+  end
+
+  def Reality.countries(*names)
+    names = Country.by_continents.keys.sort if names.empty?
+    Country::List.new(*names)
+  end
+
+  def Reality.wp
+    @wp ||= Infoboxer.wp # while Infoboxer recreates wp for each request
+  end
+end

data/lib/reality/infoboxer_templates.rb

@@ -0,0 +1,11 @@
+Infoboxer::MediaWiki::Traits.for('en.wikipedia.org') do
+  templates do
+    template 'lang' do
+      def children
+        fetch('2')
+      end
+    end
+
+    show 'US$' # TODO: in fact, has second option (year)
+  end
+end

data/lib/reality/measure.rb

@@ -0,0 +1,92 @@
+module Reality
+  class Measure
+    %w[unit].each{|mod| require_relative "measure/#{mod}"}
+    
+    attr_reader :amount, :unit
+    
+    def initialize(amount, unit)
+      @amount, @unit = Rational(amount), Unit.parse(unit)
+    end
+
+    def <=>(other)
+      check_compatibility!(other)
+      
+      amount <=> other.amount
+    end
+
+    def -@
+      self.class.new(-amount, unit)
+    end
+
+    def +(other)
+      check_compatibility!(other)
+
+      self.class.new(amount + other.amount, unit)
+    end
+
+    def -(other)
+      self + (-other)
+    end
+
+    def *(other)
+      case other
+      when Numeric
+        self.class.new(amount * other, unit)
+      when self.class
+        self.class.new(amount * other.amount, unit * other.unit)
+      else
+        fail ArgumentError, "Can't multiply by #{other.class}"
+      end
+    end
+
+    def /(other)
+      case other
+      when Numeric
+        self.class.new(amount / other, unit)
+      when self.class
+        un = unit / other.unit
+        un.scalar? ?
+          amount / other.amount :
+          self.class.new(amount / other.amount, un)
+      else
+        fail ArgumentError, "Can't divide by #{other.class}"
+      end
+    end
+
+    def **(num)
+      (num-1).times.inject(self){|res| res*self}
+    end
+
+    include Comparable
+
+    def to_s
+      '%s%s' % [formatted_amount, unit]
+    end
+
+    def inspect
+      "#<%s(%s %s)>" % [self.class, formatted_amount, unit]
+    end
+
+    private
+
+    def formatted_amount
+      # FIXME: really naive
+      if amount.abs < 1
+        amount.to_f.to_s
+      else
+        # see http://stackoverflow.com/a/6460145/3683228
+        amount.to_i.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
+      end
+    end
+
+    def check_compatibility!(other)
+      unless other.kind_of?(self.class) && other.unit == unit
+        fail ArgumentError, "#{self} incompatible with #{other}"
+      end
+    end
+  end
+
+  def Reality.Measure(*arg)
+    Measure.new(*arg)
+  end
+end

data/lib/reality/measure/unit.rb

@@ -0,0 +1,120 @@
+require 'strscan'
+
+module Reality
+  class Measure
+    class Unit
+      @unicode = true
+      
+      class << self
+        attr_accessor :unicode
+
+        UNIT_REGEX = /[a-zA-Z\$]+/ # FIXME: there are many non-ASCII units, especially in money
+        POWER_REGEX = /[²³]|\^(\d+)/
+        OP_REGEX = /[\/*·]/
+
+        def parse(str)
+          return str if str.kind_of?(Unit)
+          
+          scanner = StringScanner.new(str)
+          denom = false
+          units = []
+          
+          loop do
+            # (variable [power] operator) ....
+            unit = scanner.scan(UNIT_REGEX) or fail("Variable expected at #{scanner.rest}")
+            pow = scanner.scan(POWER_REGEX)
+            units << [unit, parse_pow(pow, denom)]
+            break if scanner.eos?
+
+            op = scanner.scan(OP_REGEX) or fail("Operator expected at #{scanner.rest}")
+            if op == '/'
+              denom and fail("Second division at #{scanner.rest}")
+              denom = true
+            end
+          end
+          new(*units)
+        end
+
+        def parse_pow(p, denom)
+          res = case p
+          when nil then 1
+          when '²' then 2
+          when '³' then 3
+          when /^\^(\d+)$/ then $1.to_i
+          else fail(ArgumentError, "Can't parse power #{p}")
+          end
+
+          denom ? -res : res
+        end
+      end
+      
+      attr_reader :components
+      
+      def initialize(*components)
+        @components = components.
+          group_by{|sig, pow| sig}.
+          map{|sig, cmps| [sig, cmps.map(&:last).inject(:+)]}.
+          reject{|sig, pow| pow.zero?}
+      end
+
+      def ==(other)
+        other.class == self.class && other.components == self.components
+      end
+
+      def scalar?
+        components.empty?
+      end
+
+      def -@
+        self.class.new(*components.map{|sig, pow| [sig, -pow]})
+      end
+
+      def *(other)
+        other.class == self.class or
+          fail(TypeError, "Can't multiply #{self.class} by #{other.class}")
+
+        self.class.new(*components, *other.components)
+      end
+
+      def /(other)
+        other.class == self.class or
+          fail(TypeError, "Can't divide #{self.class} by #{other.class}")
+
+        self * -other
+      end
+
+      def to_s
+        num, denom = components.partition{|sig, pow| pow > 0}
+        numerator = num.map{|sig, pow| "#{sig}#{power(pow)}"}.join(mul)
+        denominator = denom.map{|sig, pow| "#{sig}#{power(pow)}"}.join(mul)
+        case
+        when numerator.empty?
+          [1, denominator].join('/')
+        when denominator.empty?
+          numerator
+        else
+          [numerator, denominator].join('/')
+        end
+      end
+
+      private
+
+      UNICODE_SUPER = {2 => '²', 3 => '³'}
+
+      def mul
+        self.class.unicode ? '·' : '*'
+      end
+
+      def power(num)
+        num = num.abs
+        case num
+          when 0 then fail(ArgumentError, "0-power unit!")
+          when 1 then ''
+          when 2..3
+            self.class.unicode ? UNICODE_SUPER.fetch(num) : "^#{num}"
+          else "^#{num}"
+        end
+      end
+    end
+  end
+end