reality 0.0.2 → 0.0.3

data/lib/reality/entity/coercion.rb

@@ -0,0 +1,76 @@
+module Reality
+  class Entity
+    module Coercion
+      using Refinements
+      
+      COERCERS = {
+        entity: ->(val, **opts){
+          case val
+          when Wikidata::Link
+            Entity.new(val.label || val.id, wikidata_id: val.id)
+          when Infoboxer::Tree::Wikilink
+            Entity.new(val.link)
+          else
+            fail ArgumentError, "Can't coerce #{val.inspect} to Entity"
+          end
+        },
+        measure: ->(val, **opts){
+          u = opts[:unit] || opts[:units] or fail("Units are not defined for measure type")
+          Measure.coerce(Util::Parse.scaled_number(val.to_s), u)
+        },
+        string: ->(val, **opts){
+          val.to_s
+        },
+        tz_offset: ->(val, **opts){
+          TZOffset.parse(val.to_s)
+        },
+        coord: -> (val, **opts){
+          val.is_a?(Geo::Coord) ? val : nil
+        },
+        date: ->(val, **opts){
+          case val
+          when DateTime
+            # FIXME: in future, parse strings?..
+            val.to_date
+          when Date
+            val
+          else
+            nil
+          end
+        },
+        datetime: -> (val, **opts){
+          val.is_a?(DateTime) ? val : nil # FIXME: in future, parse strings?..
+        },
+      }
+
+      module_function
+
+      def coerce(val, type, **opts)
+        if val.kind_of?(Array) && !type.kind_of?(Array)
+          val = val.first
+        end
+
+        if opts[:parse]
+          val = opts[:parse].call(val)
+        end
+
+        return nil if val.nil?
+
+        # FIXME: better errors: including field name & class name
+        case type
+        when Array
+          type.count == 1 or fail("Only homogenous array types supported, #{type.inspect} received")
+          val.kind_of?(Array) or fail("Array type expected, #{val.inspect} received")
+          val.map{|row| coerce(row, type.first, **opts.except(:parse))}.
+              derp{|arr| arr.all?{|e| e.is_a?(Entity)} ? List.new(*arr) : arr}
+        when Symbol
+          parser = COERCERS[type] or fail("No coercion to #{type.inspect}")
+          parser.call(val, **opts)
+        else
+          fail("No parser for type #{type.inspect}")
+        end
+      end
+
+    end
+  end
+end

data/lib/reality/entity/wikidata_predicates.rb

@@ -0,0 +1,31 @@
+module Reality
+  class Entity
+    module WikidataPredicates
+      module_function
+      
+      def define(&block)
+        instance_eval(&block)
+      end
+
+      def parse(wikidata)
+        wikidata.predicates.map{|key, val|
+          [val, definitions[key]]
+        }.reject{|_, dfn| !dfn}.
+        map{|val, (symbol, type, opts)|
+          [symbol, Entity::Coercion.coerce(val, type, **opts)]
+        }.to_h
+      end
+
+      private
+      module_function
+
+      def predicate(pred, symbol, type, **opts)
+        definitions[pred] = [symbol, type, opts]
+      end
+
+      def definitions
+        @definitions ||= {}
+      end
+    end
+  end
+end

data/lib/reality/entity/wikipedia_type.rb

@@ -0,0 +1,73 @@
+module Reality
+  class Entity
+    module WikipediaType
+      def infobox_name(*infobox_names)
+        infobox_names.each do |n|
+          WikipediaType.types_by_infobox[n] = self
+        end
+      end
+
+      def infobox(name, symbol, type, **opts)
+        infobox_fields[name] = [symbol, type, opts]
+      end
+
+      def parse(symbol, type, **opts, &parser)
+        page_parsers << [symbol, type, opts, parser]
+      end
+
+      def extended(entity)
+        return unless entity.is_a? Entity
+        return if !entity.wikipage || !entity.wikipage.infobox
+        
+        values = infobox_fields.map{|name, (symbol, type, opts)|
+          var = entity.wikipage.infobox.fetch(name)
+          if var.empty?
+            [symbol, nil]
+          else
+            [symbol, Entity::Coercion.coerce(var, type, **opts)]
+          end
+        }.reject{|k, v| !v}.to_h
+
+        parsed = page_parsers.map{|symbol, type, opts, parser|
+          [symbol, Entity::Coercion.coerce(parser.call(entity.wikipage), type, **opts)]
+        }.reject{|k, v| !v}.to_h
+        
+        entity.values.update(values){|k, o, n| o || n} # Don't rewrite already fetched from WP
+        entity.values.update(parsed){|k, o, n| o || n} # Don't rewrite already fetched from WP or infobox
+      end
+
+      def symbol
+        return nil unless name
+        # FIXME: to core ext
+        name.
+          gsub(/^.+::/, '').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          downcase.
+          to_sym
+      end
+
+      private
+
+      def infobox_fields
+        @infobox_fields ||= {}
+      end
+
+      def page_parsers
+        @page_parsers ||= []
+      end
+
+      class << self
+        def types_by_infobox
+          # TODO: should be Hashie::Rash, in fact, for supporting Regexp keys
+          @types_by_infobox ||= {}
+        end
+
+        def for(entity)
+          entity.wikipage.infobox &&
+            types_by_infobox[entity.wikipage.infobox.name]
+        end
+      end
+    end
+  end
+end

data/lib/reality/extras/geonames.rb

@@ -0,0 +1,29 @@
+require 'timezone'
+require 'tzinfo'
+
+module Reality
+  module Extras
+    module Geonames
+      module CoordTimezone
+        def timezone
+          @timezone ||= guess_timezone
+        end
+
+        private
+        
+        def guess_timezone
+          Timezone::Configure.username = Reality.config.fetch('keys', 'geonames')
+          
+          gnzone = Timezone::Zone.new(latlon: [lat.to_f, lng.to_f])
+          gnzone && TZInfo::Timezone.new(gnzone.zone)
+        end
+      end
+
+      def self.included(reality)
+        reality.config.register('keys', 'geonames',
+          desc: 'GeoNames username. Can be received from http://www.geonames.org/login')
+        reality::Geo::Coord.include CoordTimezone
+      end
+    end
+  end
+end

data/lib/reality/extras/open_weather_map.rb

@@ -0,0 +1,63 @@
+require 'open_weather'
+
+module Reality
+  module Extras
+    module OpenWeatherMap
+      class Weather < Hashie::Mash
+        def temp
+          temperature
+        end
+        
+        def to_h
+          to_hash(symbolize_keys: true)
+        end
+
+        def inspect
+          "#<Reality::Weather(%s)>" %
+            [temperature, sky].map(&:to_s).reject(&:empty?).join(', ')
+        end
+        
+        class << self
+          def from_hash(hash)
+            hash = hash.dup.extend Hashie::Extensions::DeepFetch
+            new(
+                humidity: fetch(hash, 'main', 'humidity', '%'),
+                sky: hash.deep_fetch('weather', 0, 'main'),
+                temperature: fetch(hash, 'main', 'temp', '°C'),
+                pressure: fetch(hash, 'main', 'pressure', 'Pa')
+             )
+          end
+
+          private
+
+          def fetch(hash, *path, unit)
+            Reality::Measure.new(hash.deep_fetch(*path), unit)
+          rescue Hashie::Extensions::DeepFetch::UndefinedPathError, KeyError
+            nil
+          end
+        end
+      end
+
+      module CoordWeather
+        def weather
+          res = OpenWeather::Current.geocode(lat.to_f, lng.to_f,
+                        units: 'metric', APPID: appid) 
+
+          Weather.from_hash(res)
+        end
+
+        private
+
+        def appid
+          Reality.config.fetch('keys', 'open_weather_map')
+        end
+      end
+
+      def self.included(reality)
+        reality.config.register('keys', 'open_weather_map',
+          desc: 'OpenWeatherMap APPID. Can be obtained here: http://openweathermap.org/appid')
+        reality::Geo::Coord.include CoordWeather
+      end
+    end
+  end
+end

data/lib/reality/geo.rb

@@ -0,0 +1,122 @@
+require 'geokit'
+require 'sun_times'
+Geokit::default_units = :kms # TODO: use global settings
+
+module Reality
+  module Geo
+    # GeoKit, RGeo, GeoRuby -- I know, ok?
+    # It's just incredibly simple class to hold two values
+    # and show them prettily.
+    #
+    # GeoKit will be used at its time.
+    class Coord
+      attr_reader :lat, :lng
+
+      alias_method :latitude, :lat
+      alias_method :longitude, :lng
+
+      class << self
+        def from_dms(lat, lng)
+          new(decimal_from_dms(lat), decimal_from_dms(lng))
+        end
+
+        private
+
+        DIRS = {
+          'N' => +1,
+          'S' => -1,
+          'E' => +1,
+          'W' => -1
+        }
+
+        def parse_direction(dir)
+          DIRS[dir] or fail("Undefined coordinates direction: #{dir.inspect}")
+        end
+
+        def decimal_from_dms(dms)
+          sign = if dms.last.is_a?(String)
+            parse_direction(dms.pop)
+          else
+            dms.first.to_i <=> 0
+          end
+          
+          d, m, s = *dms
+          sign * (d.abs.to_i + Rational(m.to_i) / 60 + Rational(s.to_f) / 3600)
+        end
+      end
+      
+      def initialize(lat, lng)
+        @lat, @lng = Rational(lat), Rational(lng)
+      end
+
+      def distance_to(point)
+        destination_coords = normalize_point(point).to_s
+        res = Geokit::LatLng.distance_between(to_s, destination_coords, formula: :sphere)
+        Reality::Measure(res, 'km')
+      end
+
+      def direction_to(point)
+        destination_coords = normalize_point(point).to_s
+        res = Geokit::LatLng.heading_between(to_s, destination_coords)
+        Reality::Measure(res, '°')
+      end
+
+      def endpoint(direction, distance)
+        res = Geokit::LatLng.endpoint(to_s, direction.to_f, distance.to_f)
+        Coord.new res.lat, res.lng
+      end
+
+      def close_to?(point, radius)
+        area = Geokit::Bounds.from_point_and_radius(to_s, radius.to_f)
+        area.contains?(normalize_point(point).to_s)
+      end
+
+      def lat_dms(direction = true)
+        seconds = (lat.abs % 1.0) * 3600.0
+        d, m, s = lat.to_i, (seconds / 60).to_i, (seconds % 60)
+        if direction
+          [d.abs, m, s, d >= 0 ? 'N' : 'S']
+        else
+          [d, m, s]
+        end
+      end
+
+      def lng_dms(direction = true)
+        seconds = (lng.abs % 1.0) * 3600.0
+        d, m, s = lng.to_i, (seconds / 60).to_i, (seconds % 60)
+        if direction
+          [d.abs, m, s, d >= 0 ? 'E' : 'W']
+        else
+          [d, m, s]
+        end
+      end
+
+      def to_s
+        "#{lat.to_f},#{lng.to_f}"
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && lat == other.lat && lng == self.lng
+      end
+
+      def inspect
+        "#<%s(%i°%i′%i″%s,%i°%i′%i″%s)>" % [self.class, *lat_dms, *lng_dms]
+      end
+
+      def sunrise(date = Date.today)
+        SunTimes.new.rise(date, lat.to_f, lng.to_f)
+      end
+
+      def sunset(date = Date.today)
+        SunTimes.new.set(date, lat.to_f, lng.to_f)
+      end
+
+      private
+
+      def normalize_point(point)
+        return point if point.is_a?(Coord)
+        point.coord if point.respond_to?(:coord)
+      end
+    end
+  end
+end

data/lib/reality/infoboxer_templates.rb

@@ -6,6 +6,14 @@ Infoboxer::MediaWiki::Traits.for('en.wikipedia.org') do
       end
     end
 
+    template 'lang-*', match: /^lang-(\w+)$/ do
+      def children
+        fetch('1')
+      end
+    end
+
     show 'US$' # TODO: in fact, has second option (year)
+
+    show 'nts'
   end
 end

data/lib/reality/list.rb

@@ -0,0 +1,95 @@
+module Reality
+  class List < Array
+    using Refinements
+    
+    def initialize(*names)
+      super names.map(&method(:coerce))
+    end
+
+    def load!
+      partition(&:wikidata_id).tap{|wd, wp|
+          load_by_wikipedia(wp)
+          load_by_wikidata(wd)
+        }
+      self
+    end
+
+    [:select, :reject, :sort, :sort_by,
+    :compact, :-, :map, :first, :last, :sample, :shuffle].each do |sym|
+      define_method(sym){|*args, &block|
+        ensure_type super(*args, &block)
+      }
+    end
+
+    def inspect
+      "#<#{self.class.name}[#{map(&:to_s?).join(', ')}]>"
+    end
+
+    def describe
+      load! unless all?(&:loaded?)
+      
+      meta = {
+        types: map(&:wikipedia_type).compact.map(&:symbol).
+          group_count.sort_by(&:first).map{|t,c| "#{t} (#{c})"}.join(', '),
+         keys: map(&:values).map(&:keys).flatten.
+          group_count.sort_by(&:first).map{|k,c| "#{k} (#{c})"}.join(', '),
+      }
+      # hard to read, yet informative version:
+      #keys = map(&:values).map(&:to_a).flatten(1).
+            #group_by(&:first).map{|key, vals|
+              #values = vals.map(&:last)
+              #[key, "(#{values.compact.count}) example: #{values.compact.first.inspect}"]
+            #}.to_h
+      puts Util::Format.describe("#<#{self.class.name}(#{count} items)>", meta)
+    end
+
+    private
+
+    def load_by_wikipedia(entities)
+      return if entities.empty?
+      
+      pages = Infoboxer.wp.get_h(*entities.map(&:name))
+      datum = Wikidata::Entity.
+        fetch_list(*pages.values.compact.map(&:title))
+
+      entities.each do |entity|
+        page = pages[entity.name]
+        data = page && datum[page.title]
+        entity.setup!(wikipage: page, wikidata: data)
+      end
+    end
+
+    def load_by_wikidata(entities)
+      return if entities.empty?
+      
+      datum = Wikidata::Entity.
+        fetch_list_by_id(*entities.map(&:wikidata_id))
+      pages = Infoboxer.wp.
+        get_h(*datum.values.compact.map(&:en_wikipage).compact)
+      entities.each do |entity|
+        data = datum[entity.wikidata_id]
+        page = data && pages[data.en_wikipage]
+        entity.setup!(wikipage: page, wikidata: data)
+      end
+    end
+
+    def ensure_type(arr)
+      if arr.kind_of?(Array) && arr.all?{|e| e.is_a?(Entity)}
+        List[*arr]
+      else
+        arr
+      end
+    end
+
+    def coerce(val)
+      case val
+      when String
+        Entity.new(val)
+      when Entity
+        val
+      else
+        fail ArgumentError, "Can't coerce #{val.inspect} to Entity"
+      end
+    end
+  end
+end