reality 0.0.2 → 0.0.3

data/lib/reality/measure.rb

@@ -3,6 +3,10 @@ module Reality
     %w[unit].each{|mod| require_relative "measure/#{mod}"}
     
     attr_reader :amount, :unit
+
+    def Measure.coerce(amount, unit)
+      amount && unit && new(amount, unit)
+    end
     
     def initialize(amount, unit)
       @amount, @unit = Rational(amount), Unit.parse(unit)
@@ -14,6 +18,10 @@ module Reality
       amount <=> other.amount
     end
 
+    def ==(other)
+      amount == other.amount && unit == other.unit
+    end
+
     def -@
       self.class.new(-amount, unit)
     end
@@ -60,25 +68,23 @@ module Reality
     include Comparable
 
     def to_s
-      '%s%s' % [formatted_amount, unit]
+      '%s%s' % [Util::Format.number(amount), unit]
     end
 
-    def inspect
-      "#<%s(%s %s)>" % [self.class, formatted_amount, unit]
+    def to_f
+      amount.to_f
     end
 
-    private
+    def to_i
+      amount.to_i
+    end
 
-    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
+    def inspect
+      "#<%s(%s %s)>" % [self.class, Util::Format.number(amount), unit]
     end
 
+    private
+
     def check_compatibility!(other)
       unless other.kind_of?(self.class) && other.unit == unit
         fail ArgumentError, "#{self} incompatible with #{other}"

data/lib/reality/measure/unit.rb

@@ -8,7 +8,7 @@ module Reality
       class << self
         attr_accessor :unicode
 
-        UNIT_REGEX = /[a-zA-Z\$]+/ # FIXME: there are many non-ASCII units, especially in money
+        UNIT_REGEX = /[^\s\+\*\/\/\^²³·]+/
         POWER_REGEX = /[²³]|\^(\d+)/
         OP_REGEX = /[\/*·]/
 
@@ -97,6 +97,10 @@ module Reality
         end
       end
 
+      def inspect
+        "#<#{self.class}(#{to_s})>"
+      end
+
       private
 
       UNICODE_SUPER = {2 => '²', 3 => '³'}

data/lib/reality/methods.rb

@@ -0,0 +1,16 @@
+require 'forwardable'
+
+module Reality
+  module Methods
+    def Entity(name, entity_class = nil)
+      Entity.load(name, entity_class)
+    end
+
+    def List(*names)
+      Entity::List.new(*names)
+    end
+
+    extend Forwardable
+    def_delegators Dictionaries, :countries, :continents
+  end
+end

data/lib/reality/pretty_inspect.rb

@@ -0,0 +1,11 @@
+class Date
+  def inspect
+    strftime('#<Date: %Y-%m-%d>')
+  end
+end
+
+class Rational
+  def inspect
+    Reality::Util::Format.number(self)
+  end
+end

data/lib/reality/refinements.rb

@@ -0,0 +1,26 @@
+module Reality
+  module Refinements
+    refine Object do
+      def derp
+        yield self
+      end
+    end
+
+    refine Hash do
+      def except(*keys)
+        reject { |k, _v| keys.include?(k) }
+      end
+    end
+
+    refine Array do
+      def group_count(&block)
+        block ||= ->(x) { x }
+        Hash.new{ 0 }.tap{|res|
+          each do |val|
+            res[block.call(val)] += 1
+          end
+        }
+      end
+    end
+  end
+end

data/lib/reality/shortcuts.rb

@@ -0,0 +1,11 @@
+module Reality
+  module Methods
+    def E(*arg)
+      Entity(*arg)
+    end
+
+    def L(*arg)
+      List(*arg)
+    end
+  end
+end

data/lib/reality/tz_offset.rb

@@ -0,0 +1,64 @@
+module Reality
+  class TZOffset
+    using Refinements
+    
+    attr_reader :minutes
+
+    MINUSES = /[−—–]/
+
+    def self.parse(text)
+      text = text.gsub(MINUSES, '-')
+      
+      case text
+      when /^[A-Z]{3}$/
+        Time.zone_offset(text)
+      when /^(?:UTC|GMT)?([+-]\d{1,2}:?\d{2})$/
+        Time.zone_offset($1)
+      when /^(?:UTC|GMT)?([+-]\d{1,2})/
+        $1.to_i * 3600
+      end.derp{|sec| sec && new(sec / 60)}
+    end
+    
+    def initialize(minutes)
+      @minutes = minutes
+    end
+
+    def inspect
+      '#<%s(UTC%+03i:%02i)>' % [self.class.name, *minutes.divmod(60)]
+    end
+
+    def to_s
+      '%+03i:%02i' % minutes.divmod(60)
+    end
+
+    def <=>(other)
+      other.is_a?(TZOffset) or fail ArgumentError, "Can't compare TZOffset with #{other.class}"
+      minutes <=> other.minutes
+    end
+
+    include Comparable
+
+    def now
+      convert(Time.now)
+    end
+
+    def local(*values)
+      values << 0 until values.count == 6
+      Time.new(*values, to_s)
+    end
+
+    # FIXME: usec are lost
+    def convert(tm)
+      pattern = tm.utc + minutes * 60
+      Time.new(
+        pattern.year,
+        pattern.month,
+        pattern.day,
+        pattern.hour,
+        pattern.min,
+        pattern.sec,
+        to_s
+      )
+    end
+  end
+end

data/lib/reality/util/formatters.rb

@@ -0,0 +1,35 @@
+module Reality
+  module Util
+    module Format
+      module_function
+
+      def number(n)
+        case n.abs
+        when 0..1
+          n.to_f.to_s.sub(/(\.0*[1-9]).*$/, '\1')
+        when 1..4
+          ('%.2f' % n).sub(/\.?0+$/, '')
+        when 1_000..Float::INFINITY
+          # see http://stackoverflow.com/a/6460145/3683228
+          n.to_i.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
+        else
+          n.to_i.to_s
+        end
+      end
+
+      def describe(title, hash)
+        # hash may be an array, in fact :)
+        key_width = hash.map(&:first).map(&:length).max.to_i + 1
+
+        [
+          '-' * title.length,
+          title,
+          '-' * title.length,
+          *hash.sort_by(&:first).map{|key, value|
+            "#{key.to_s.rjust(key_width)}: #{value}"
+          }
+        ].join("\n")
+      end
+    end
+  end
+end

data/lib/reality/util/parsers.rb

@@ -0,0 +1,53 @@
+module Reality
+  module Util
+    module Parse
+      module_function
+
+      def scaled_number(str)
+        match, amount, scale = */^([0-9.,]+)[[:space:]]*(#{SCALES_REGEXP})?/.match(str)
+        match or return nil
+
+        if scale
+          number(amount) * fetch_scale(scale)
+        else
+          number(amount)
+        end
+      end
+
+      def number(str)
+        str = str.gsub(',', '').tr('−', '-')
+        case str
+        when /^-?\d+$/
+          str.to_i
+        when /^-?\d+\.\d+$/
+          str.to_f
+        else
+          nil
+        end
+      end
+
+      private
+
+      module_function
+
+      # 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 fetch_scale(str)
+        _, res = SCALES.detect{|key, val| str.start_with?(key)}
+
+        res or fail("Scale not found: #{str} for #{self}")
+      end
+      
+    end
+  end
+end

data/lib/reality/version.rb

@@ -0,0 +1,6 @@
+module Reality
+  MAJOR = 0
+  MINOR = 0
+  PATCH = 3
+  VERSION = [MINOR, MAJOR, PATCH].join('.')
+end

data/lib/reality/wikidata.rb

@@ -0,0 +1,310 @@
+module Reality
+  using Reality::Refinements
+  
+  module Wikidata
+    class Link
+      attr_reader :id, :label
+
+      def initialize(id, label = nil)
+        @id, @label = id, label
+      end
+
+      def inspect
+        "#<#{self.class}(#{[id, label].compact.join(': ')})>"
+      end
+
+      def to_s
+        label || id
+      end
+    end
+
+    # FIXME: I should be burn in hell for this mess. But it works. Somehow.
+    class Entity
+      PREFIX = %Q{
+        PREFIX wikibase: <http://wikiba.se/ontology#>
+        PREFIX wd: <http://www.wikidata.org/entity/> 
+        PREFIX wdt: <http://www.wikidata.org/prop/direct/>
+        PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+        PREFIX p: <http://www.wikidata.org/prop/>
+        PREFIX v: <http://www.wikidata.org/prop/statement/>
+        PREFIX schema: <http://schema.org/>
+      }
+      
+      SINGLE_QUERY = %Q{
+        #{PREFIX}
+        
+        SELECT ?id ?p ?o ?oLabel  WHERE {
+          <https://en.wikipedia.org/wiki/%{title}> schema:about ?id .
+          {
+            ?id ?p ?o .
+            FILTER(STRSTARTS(STR(?p), "http://www.wikidata.org/prop/direct/"))
+          } union {
+            ?id ?p ?o .
+            filter(langMatches(lang(?o), "EN")).
+            filter(?p = rdfs:label)
+          }
+          SERVICE wikibase:label {
+            bd:serviceParam wikibase:language "en" .
+          }
+         }
+      }
+
+      ID_QUERY = %Q{
+        #{PREFIX}
+        
+        SELECT ?id ?p ?o ?oLabel  WHERE {
+          bind(wd:%{id} as ?id)
+          {
+            ?id ?p ?o .
+            FILTER(
+              STRSTARTS(STR(?p), "http://www.wikidata.org/prop/direct/") ||
+              (?p = rdfs:label && langMatches(lang(?o), "EN"))
+            )
+          } union {
+            bind(schema:about as ?p) .
+            ?o schema:about ?id .
+            filter(strstarts(str(?o), "https://en.wikipedia.org/wiki/"))
+          }
+          SERVICE wikibase:label {
+            bd:serviceParam wikibase:language "en" .
+          }
+         }
+      }
+
+      MULTIPLE_QUERY = %Q{
+        #{PREFIX}
+
+        SELECT ?id ?p ?o ?oLabel  WHERE {
+          %{selectors} .
+          {
+            ?id ?p ?o .
+            FILTER(
+              STRSTARTS(STR(?p), "http://www.wikidata.org/prop/direct/") ||
+              (?p = rdfs:label && langMatches(lang(?o), "EN"))
+            )
+          } union {
+            bind(schema:about as ?p) .
+            ?o schema:about ?id .
+            filter(strstarts(str(?o), "https://en.wikipedia.org/wiki/"))
+          }
+          SERVICE wikibase:label {
+            bd:serviceParam wikibase:language "en" .
+          }
+         }
+      }
+      MULTIPLE_IDS_QUERY = %Q{
+        #{PREFIX}
+
+        SELECT ?id ?p ?o ?oLabel  WHERE {
+          %{selectors} .
+          {
+            ?id ?p ?o .
+            FILTER(
+              STRSTARTS(STR(?p), "http://www.wikidata.org/prop/direct/") ||
+              (?p = rdfs:label && langMatches(lang(?o), "EN"))
+            )
+          } union {
+            bind(schema:about as ?p) .
+            ?o schema:about ?id .
+            filter(strstarts(str(?o), "https://en.wikipedia.org/wiki/"))
+          }
+          SERVICE wikibase:label {
+            bd:serviceParam wikibase:language "en" .
+          }
+         }
+      }
+      SELECTOR = %Q{
+        {
+          <https://en.wikipedia.org/wiki/%{title}> schema:about ?id
+        }
+      }
+      IDSELECTOR = %Q{
+        {
+          BIND(wd:%{id} as ?id)
+        }
+      }
+
+      UNSAFE = Regexp.union(URI::UNSAFE, /[,()']/)
+      
+      class << self
+        def faraday
+          @faraday ||= Faraday.new(url: 'https://query.wikidata.org/sparql'){|f|
+            f.adapter Faraday.default_adapter
+          }
+        end
+
+        def fetch(title)
+          title = URI.escape(title, UNSAFE)
+          faraday.get('', query: SINGLE_QUERY % {title: title}, format: :json).
+            derp{|res| from_sparql(res.body, subject: 'id', predicate: 'p', object: 'o', object_label: 'oLabel')}
+        end
+
+        def fetch_by_id(id)
+          faraday.get('', query: ID_QUERY % {id: id}, format: :json).
+            derp{|res| from_sparql(res.body, subject: 'id', predicate: 'p', object: 'o', object_label: 'oLabel')}.
+            first
+        end
+
+        WIKIURL = 'https://en.wikipedia.org/wiki/%{title}'
+
+        MAX_SLICE = 20
+
+        def fetch_list(*titles)
+          titles.each_slice(MAX_SLICE).map{|titles_chunk|
+            fetch_small_list(*titles_chunk)
+          }.inject(:merge)
+        end
+
+        def fetch_list_by_id(*ids)
+          ids.each_slice(MAX_SLICE).map{|ids_chunk|
+            fetch_small_idlist(*ids_chunk)
+          }.inject(:merge)
+        end
+
+        def fetch_small_list(*titles)
+          titles.
+            map{|t| SELECTOR % {title: URI.escape(t, UNSAFE)}}.
+            join(' UNION ').
+            derp{|selectors| MULTIPLE_QUERY % {selectors: selectors}}.
+            derp{|query|
+              faraday.get('', query: query, format: :json)
+            }.
+            derp{|res|
+              from_sparql(
+                res.body,
+                subject: 'id',
+                predicate: 'p',
+                object: 'o',
+                object_label: 'oLabel')
+            }.
+            map{|e|
+              [e.en_wikipage, e]
+            }.to_h
+        end
+
+
+        def fetch_small_idlist(*ids)
+          ids.
+            map{|i| IDSELECTOR % {id: i}}.
+            join(' UNION ').
+            derp{|selectors| MULTIPLE_IDS_QUERY % {selectors: selectors}}.
+            derp{|query|
+              faraday.get('', query: query, format: :json)
+            }.
+            derp{|res|
+              from_sparql(
+                res.body,
+                subject: 'id',
+                predicate: 'p',
+                object: 'o',
+                object_label: 'oLabel')
+            }.
+            map{|e|
+              [e.id, e]
+            }.to_h
+        end
+        
+        def from_sparql(sparql_json, subject: 'subject', predicate: 'predicate', object: 'object', object_label: 'object_label')
+          JSON.parse(sparql_json)['results']['bindings'].map{|row|
+            [
+              row[subject]['value'].sub('http://www.wikidata.org/entity/', ''),
+              row[predicate]['value'].sub('http://www.wikidata.org/prop/direct/', ''),
+              row[object].merge('label' => row[object_label]['value'])
+            ]
+          }.group_by(&:first).
+          map{|id, rows|
+            new(id, hash_from_predicates(rows))
+          }
+        end
+
+        def hash_from_predicates(rows)
+          rows.map{|s, p, o| [p, parse_value(o)]}.
+            group_by(&:first).map{|p, gs| [p, gs.map(&:last).compact]}.
+            to_h
+        end
+
+        def parse_value(hash)
+          case hash['type']
+          when 'literal'
+            parse_literal(hash)
+          when 'uri'
+            parse_uri(hash)
+          when 'bnode'
+            nil
+          else
+            fail ArgumentError, "Unidentifieble datatype: #{hash['type']} in #{hash}"
+          end
+        end
+
+        def parse_uri(hash)
+          if hash['value'] =~ %r{https?://www\.wikidata\.org/entity/([^/]+)$}
+            Link.new($1, hash['label'])
+          else
+            hash['value']
+          end
+        end
+
+        def parse_literal(hash)
+          case hash['datatype']
+          when 'http://www.w3.org/2001/XMLSchema#decimal'
+            hash['value'].to_i
+          when 'http://www.w3.org/2001/XMLSchema#dateTime'
+            DateTime.parse(hash['value'])
+          when 'http://www.opengis.net/ont/geosparql#wktLiteral'
+            # TODO: WTF
+            if hash['value'] =~ /^\s*point\s*\(\s*([-\d.]+)\s+([-\d.]+)\s*\)\s*$/i
+              lat, lng = $1, $2
+              Geo::Coord.new(lat.to_f, lng.to_f)
+            else
+              fail ArgumentError, "Unparseable WKT: #{hash['value']}"
+            end
+          else
+            if hash['xml:lang'] && hash['xml:lang'] != 'en'
+              nil
+            else
+              hash['value']
+            end
+          end
+        end
+      end
+
+      attr_reader :id, :predicates
+
+      def initialize(id, predicates)
+        @id, @predicates = id, predicates
+      end
+
+      def [](pred)
+        @predicates[pred]
+      end
+
+      def label
+        self['http://www.w3.org/2000/01/rdf-schema#label'].first
+      end
+
+      def about
+        self['http://schema.org/about']
+      end
+
+      def en_wikipage
+        return nil unless about
+        
+        name = about.first.
+          scan(%r{https://en\.wikipedia\.org/wiki/(.+)$}).
+          flatten.first.derp{|s| URI.unescape(s)}
+      end
+
+      def inspect
+        "#<#{self.class}(#{[id, label].compact.join(': ')})>"
+      end
+
+      def to_s
+        label || id
+      end
+
+      def to_h
+        @predicates
+      end
+    end
+  end
+end