reality 0.0.2 → 0.0.3

data/lib/reality.rb

@@ -1,15 +1,34 @@
 require 'infoboxer'
+require 'yaml'
 
 module Reality
-  require_relative 'reality/infoboxer_templates'
-  
-  # basic functionality
-  %w[measure].each do |mod|
-    require_relative "reality/#{mod}"
+  def self.require_(*modules)
+    modules.flatten.flat_map{|pattern|
+      Dir[File.expand_path("../reality/#{pattern}.rb", __FILE__)]
+    }.each(&Kernel.method(:require))
   end
 
+  # basic functionality
+  require_ %w[version refinements config measure geo tz_offset]
+  require_ %w[util/parsers util/formatters]
+
+  # engines
+  require_ %w[infoboxer_templates wikidata]
+  Infoboxer.user_agent = "Reality/#{VERSION} (https://github.com/molybdenum-99/reality; zverok.offline@gmail.com)"
+
   # entities
-  %w[country].each do |mod|
-    require_relative "reality/#{mod}"
+  require_ %w[entity list]
+  require_ %w[definitions/*]
+  require_ %w[methods]
+
+  extend Methods
+
+  def self.reload!
+    require_ %w[definitions/*]
   end
+
+  # extras
+  require_ %w[extras/open_weather_map extras/geonames]
+  include Extras::OpenWeatherMap
+  include Extras::Geonames
 end

data/lib/reality/config.rb

@@ -0,0 +1,46 @@
+require 'hashie'
+
+module Reality
+  class Config
+    attr_reader :keys, :data
+    
+    def initialize
+      @keys = {}
+      @data = {}.extend Hashie::Extensions::DeepFetch
+    end
+
+    def load(str)
+      if File.exists?(str)
+        str = File.read(str)
+      end
+
+      @data.update(YAML.load(str))
+    end
+
+    def fetch(*path)
+      data.deep_fetch(*path){
+        if (known = @keys[path])
+          fail KeyError, "Expected #{path.join('.')} to exist in config. It is #{known[:desc]}"
+        else
+          fail KeyError, "Expected #{path.join('.')} to exist in config."
+        end
+      }
+    end
+    
+    def register(*path, **opts)
+      @keys[path] = opts
+    end
+  end
+
+  def Reality.config
+    @config ||= Config.new
+  end
+
+  def Reality.configure(cfg)
+    if cfg == :demo
+      config.load(File.expand_path('../../../config/demo.yml', __FILE__))
+    else
+      config.load(cfg)
+    end
+  end
+end

data/lib/reality/definitions/dictionaries.rb

@@ -0,0 +1,67 @@
+module Reality
+  module Dictionaries
+    module_function
+
+    using Reality::Refinements
+
+    def countries
+      List.new(*countries_by_continents_cache.keys)
+    end
+
+    def continents
+      @continents ||=
+        Infoboxer.wp.get('Continent').
+          sections('Area and population').tables.first.
+          lookup(:TableHeading, index: 0).lookup(:Wikilink).
+          derp{|links| Entity::Coercion.coerce(links, [:entity])}
+    end
+
+    CITY_SYNONYMS = [
+      'City',
+      'Municipality',
+      'Commune',      # France
+      'GCCSA/SUA'     # Australia
+    ]
+
+    CITIES_PAGE_BY_COUNTRY =
+      Hash.new{|_, name| 'List of cities in %s' % name}.
+      merge(
+        'United States' => 'List of United States cities by population',
+        'Australia' => 'List of cities in Australia by population'
+      )
+
+    def cities_by_country(name)
+      page = Infoboxer.wp.get(CITIES_PAGE_BY_COUNTRY[name]) or
+              return Entity::List.new()
+
+      page.tables.map{|t|
+        t.heading_row or next []
+        
+        idx = t.heading_row.children.
+          index{|c| c.text =~ /\bname\b/i || CITY_SYNONYMS.any?{|s| c.text.strip.start_with?(s)}} or next []
+          
+        t.lookup(:TableCell, index: idx).lookup(:Wikilink)
+      }.flatten.
+      derp{|links| Entity::Coercion.coerce(links, [:entity])}
+    end
+
+    def countries_by_continent(name)
+      countries_by_continents_cache.select{|k, v| v == name}.map(&:first).
+        derp{|names| List.new(*names)}
+    end
+
+    def countries_by_continents_cache
+      @by_continents ||= Infoboxer.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).
+        reject{|country, continent| country == 'Holy See'}. # it has [Vatican City]/[Holy See]
+        to_h
+    end    
+  end
+end

data/lib/reality/definitions/helpers.rb

@@ -0,0 +1,34 @@
+require 'time_boots'
+
+module Reality
+  # Just assorted "cool things", included into all entities
+  # Subject to change/refactor
+  module Helpers
+    def alive?
+      !birthday.nil? && date_of_death.nil?
+    end
+
+    def dead?
+      !date_of_death.nil?
+    end
+
+    def age_at(tm)
+      # TimeBoots fail with Time vs Date :(
+      #birthday && TimeBoots.year.measure(birthday, tm)
+
+      from = birthday || created_at || published_at
+
+      if from.month < tm.month || from.month == tm.month && from.day <= tm.day
+        tm.year - from.year
+      else
+        tm.year - from.year - 1
+      end
+    end
+
+    def age
+      age_at(Date.today)
+    end
+  end
+
+  Reality::Entity.include Helpers
+end

data/lib/reality/definitions/wikidata.rb

@@ -0,0 +1,105 @@
+module Reality
+  Entity::WikidataPredicates.define do
+    # Generic relations ------------------------------------------------
+    predicate 'P361', :part_of, [:entity]
+    predicate 'P527', :parts, [:entity] # aliases: :members
+    
+    predicate 'P155', :follows, :entity
+    predicate 'P156', :precedes, :entity
+    predicate 'P571', :created_at, :date # TODO: aliases: :founded_at, :incepted_at
+
+    predicate 'P740', :location, :entity
+
+    predicate 'P737', :influenced_by, [:entity]
+
+    # Object features --------------------------------------------------
+    predicate 'P2048', :height, :measure, unit: 'm'
+    
+    # Geography --------------------------------------------------------
+    predicate 'P625', :coord, :coord
+
+    predicate 'P30' , :continent, :entity
+    predicate 'P17' , :country, :entity
+    predicate 'P610', :highest_point, :entity
+
+    predicate 'P36' , :capital, :entity
+    predicate 'P150', :adm_divisions, [:entity]
+
+    predicate 'P47' , :neighbours, [:entity]
+
+    predicate 'P2046', :area, :measure, unit: 'km²'
+    predicate 'P2044', :elevation, :measure, unit: 'm'
+
+    # Economy and socilogy ---------------------------------------------
+    predicate 'P38', :currency, :entity
+    predicate 'P463', :organizations, [:entity]
+    predicate 'P2131', :gdp_nominal, :measure, unit: '$'
+    predicate 'P1082',:population, :measure, unit: 'person'
+
+    predicate 'P35', :head_of_state, :entity
+
+    # References -------------------------------------------------------
+    predicate 'P297', :iso2_code, :string
+    predicate 'P298', :iso3_code, :string
+    predicate 'P78', :tld, :string
+    predicate 'P474', :calling_code, :string
+    predicate 'P421', :tz_offset, :tz_offset
+
+    # People -----------------------------------------------------------
+    # personal
+    predicate 'P19', :birth_place, :entity
+    predicate 'P569', :birthday, :date
+    predicate 'P570', :date_of_death, :date
+    predicate 'P20', :place_of_death, :entity
+    predicate 'P21', :sex, :string
+    predicate 'P735', :given_name, :string
+
+    # family
+    predicate 'P26', :spouse, :entity
+    predicate 'P40', :children, [:entity]
+    predicate 'P22', :father, :entity
+
+    # social
+    predicate 'P551', :residence, :entity
+    predicate 'P27', :citizenship, :entity
+    predicate 'P39', :position, :string
+    predicate 'P106', :occupations, [:string]
+
+    # General creative works & workers ---------------------------------
+    predicate 'P577', :published_at, :date
+    predicate 'P136', :genres, [:string]
+    predicate 'P166', :awards, [:entity]
+    predicate 'P1411', :nominations, [:entity]
+    predicate 'P921', :work_subjects, [:string]
+    predicate 'P364', :original_languages, [:string]
+
+    # Music album ------------------------------------------------------
+    predicate 'P658', :tracks, [:string]
+    predicate 'P175', :performer, :entity
+    #predicate 'P175', :performers, [:entity] - TODO
+
+    # Companies --------------------------------------------------------
+    predicate 'P112', :founders, [:entity]
+    predicate 'P127', :owners, [:entity]
+    predicate 'P169', :ceo, :entity
+    predicate 'P1128', :employees_count, :measure, unit: 'person'
+    predicate 'P452', :industry, :string
+
+    # Software ---------------------------------------------------------
+    predicate 'P178', :developers, [:entity]
+    predicate 'P275', :licenses, [:string]
+    predicate 'P348', :version, :string
+
+    # Movies -----------------------------------------------------------
+    predicate 'P57', :directors, [:entity]
+    predicate 'P162', :producers, [:entity]
+    predicate 'P161', :actors, [:entity]
+
+    # Wehicles ---------------------------------------------------------
+    predicate 'P1029', :crew_members, [:entity]
+
+    # Fictional entities -----------------------------------------------
+    predicate 'P1080', :fictional_universe, :string
+    predicate 'P1441', :present_in_works, [:entity]
+  end
+end

data/lib/reality/definitions/wikipedia_character.rb

@@ -0,0 +1,17 @@
+module Reality
+  module Character
+    extend Entity::WikipediaType
+
+    infobox_name 'Infobox character'
+
+    # FIXME: Both should be auto-parsed
+    infobox 'species', :species, :entity,
+            parse: ->(var){var.lookup(:Wikilink).first}
+            
+    infobox 'affiliation', :affiliations, [:entity],
+            parse: ->(var){var.lookup(:Wikilink)}
+
+    infobox 'portrayer', :portrayer, :entity,
+            parse: ->(var){var.lookup(:Wikilink).first}
+  end
+end

data/lib/reality/definitions/wikipedia_city.rb

@@ -0,0 +1,19 @@
+module Reality
+  module City
+    extend Entity::WikipediaType
+
+    infobox_name 'Infobox settlement',
+                 'Infobox city Japan',
+                 'Infobox Russian city', 'Infobox Russian town',
+                    'Infobox Russian inhabited locality', 
+                    'Infobox Russian federal subject'
+
+    infobox 'name', :long_name, :string
+
+    infobox 'area_km2', :area, :measure, unit: 'km²'
+    infobox 'area_total_km2', :area, :measure, unit: 'km²'
+
+    infobox 'population_total', :population, :measure, unit: 'person'
+    infobox 'population_metro', :population_metro, :measure, unit: 'person'
+  end
+end

data/lib/reality/definitions/wikipedia_continent.rb

@@ -0,0 +1,21 @@
+module Reality
+  module Continent
+    extend Entity::WikipediaType
+
+    infobox_name 'Infobox continent', 'Infobox Continent' # FIXME: Infoboxer is a bit dumb about this
+
+    infobox 'area', :area, :measure, unit: 'km²',
+      parse: ->(var){
+        str = var.children.
+          templates(name: /^Convert$/i). # Infoboxer is dumb here, tooo :(
+          fetch('1').text
+
+        str = var.children.text if str.empty?
+        Util::Parse.scaled_number(str)
+      }
+
+    def countries
+      @countries ||= Dictionaries.countries_by_continent(name)
+    end
+  end
+end

data/lib/reality/definitions/wikipedia_country.rb

@@ -0,0 +1,23 @@
+module Reality
+  module Country
+    extend Entity::WikipediaType
+
+    infobox_name 'Infobox country'
+
+    infobox 'conventional_long_name', :long_name, :string
+    infobox 'area_km2', :area, :measure, unit: 'km²'
+
+    infobox 'GDP_PPP', :gdp_ppp, :measure, unit: '$',
+              parse: ->(var){
+                str = var.text.strip.sub(/^((Int|US)?\$|USD)/, '')
+                Util::Parse.scaled_number(str)
+              }
+
+    infobox 'population_census', :population, :measure, unit: 'person'
+    infobox 'population_estimate', :population, :measure, unit: 'person'
+
+    def cities
+      @cities ||= Dictionaries.cities_by_country(name)
+    end
+  end
+end

data/lib/reality/definitions/wikipedia_musical_artist.rb

@@ -0,0 +1,15 @@
+module Reality
+  module MusicalArtist
+    extend Entity::WikipediaType
+
+    infobox_name 'Infobox musical artist'
+
+    parse :albums, [:entity] do |page|
+      if (sec = page.sections('Discography').first)
+        sec.lookup(:UnorderedList).first.lookup(:Wikilink, :italic?)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/reality/definitions/wikipedia_person.rb

@@ -0,0 +1,17 @@
+module Reality
+  module Person
+    extend Entity::WikipediaType
+
+    infobox_name 'Infobox person'
+
+    # Singular artists, like Bjork or David Bowie
+    # TODO: should not repeat code from musical artist, but include it from module?
+    parse :albums, [:entity] do |page|
+      if (sec = page.sections('Discography').first)
+        sec.lookup(:UnorderedList).first.lookup(:Wikilink, :italic?)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/reality/entity.rb

@@ -0,0 +1,152 @@
+module Reality
+  require_ %w[entity/coercion entity/wikidata_predicates entity/wikipedia_type]
+  
+  class Entity
+    using Refinements
+    
+    attr_reader :wikipage, :wikidata, :wikidata_id
+    attr_reader :values, :wikipedia_type
+    
+    def initialize(name, wikipage: nil, wikidata: nil, wikidata_id: nil, load: false)
+      @name = name
+      @wikipage, @wikidata, @wikidata_id = wikipage, wikidata, wikidata_id
+      @values = {}
+      
+      load! if load
+      after_load if @wikipage
+    end
+
+    def name
+      @wikipage ? @wikipage.title : @name
+    end
+
+    def inspect
+      if @wikipedia_type && @wikipedia_type.symbol
+        "#<#{self.class}#{loaded? ? '' : '?'}(#{name}):#{@wikipedia_type.symbol}>"
+      else
+        "#<#{self.class}#{loaded? ? '' : '?'}(#{name})>"
+      end
+    end
+
+    def _describe
+      load! unless loaded?
+      Util::Format.describe(inspect, values.map{|k,v| [k, v.inspect]})
+    end
+
+    def describe
+      puts _describe
+      nil
+    end
+
+    def to_s
+      name
+    end
+
+    def to_s?
+      # FIXME: fuuuuuuuu
+      "#{name.include?(',') ? '"' + name + '"' : name}#{loaded? ? '' : '?'}"
+    end
+
+    def load!
+      if @wikidata_id
+        @wikidata = Wikidata::Entity.fetch_by_id(@wikidata_id)
+        if @wikidata && @wikidata.en_wikipage
+          @wikipage = Infoboxer.wikipedia.get(@wikidata.en_wikipage)
+        end
+      else
+        @wikipage = Infoboxer.wikipedia.get(name)
+        if @wikipage
+          @wikidata = Wikidata::Entity.fetch(@wikipage.title).first
+        end
+      end
+      after_load
+      self
+    end
+
+    def setup!(wikipage: nil, wikidata: nil)
+      @wikipage, @wikidata = wikipage, wikidata
+      after_load if @wikipage
+    end
+
+    def loaded?
+      !!@wikipage
+    end
+
+    # Don't try to convert me!
+    UNSUPPORTED_METHODS = [:to_hash, :to_ary, :to_a, :to_str, :to_int]
+
+    def method_missing(sym, *arg, **opts, &block)
+      if arg.empty? && opts.empty? && !block && sym !~ /[=?!]/ &&
+        !UNSUPPORTED_METHODS.include?(sym)
+        
+        load! unless loaded?
+
+        # now some new method COULD emerge while loading
+        if methods.include?(sym)
+          send(sym)
+        else
+          values[sym]
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to?(sym)
+      sym !~ /[=?!]/ && !UNSUPPORTED_METHODS.include?(sym) || super
+    end
+
+    class << self
+      def load(name, type = nil)
+        Entity.new(name, load: true).tap{|entity|
+          return nil if entity.instance_variable_get('@wikipage').nil?
+          return nil if type && entity.wikipedia_type != type
+        }
+      end
+    end
+
+    #def to_h
+      #if respond_to?(:properties)
+        #properties.map{|sym|
+          #[sym, to_simple_type(self.send(sym))]
+        #}.to_h
+      #else
+        #{}
+      #end
+    #end
+
+    protected
+
+    def after_load
+      if @wikipage && !@wikipedia_type
+        if (@wikipedia_type = WikipediaType.for(self))
+          extend(@wikipedia_type)
+        end
+      end
+      if @wikidata
+        @values.update(WikidataPredicates.parse(@wikidata))
+      end
+      (@values.keys - methods).each do |sym|
+        define_singleton_method(sym){@values[sym]}
+      end
+    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 Entity
+        val.to_s
+      when Reality::Measure
+        val.amount.to_i
+      else
+        fail ArgumentError, "Non-coercible value #{val.class}"
+      end
+    end
+
+  end
+end