inat-get 0.8.0.11

data/lib/inat/data/sets/dataset.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative 'listers'
+require_relative 'list'
+
+class DataSet
+
+  attr_reader :time
+  attr_reader :object
+  attr_reader :observations
+
+  def initialize object, observations, time: Time::new
+    @object = object
+    @time = time
+    @observations = observations.sort_by { |o| o.sort_key }.uniq
+    @sorted = true
+    @by_id = {}
+    @observations.each do |o|
+      @by_id[o.id] = o
+    end
+  end
+
+  def self.zero
+    new nil, []
+  end
+
+  include Enumerable
+
+  def each
+    if block_given?
+      @observations.sort_by! { |o| o.sort_key } unless @sorted
+      @sorted = true
+      @observations.each do |o|
+        yield o
+      end
+    else
+      to_enum :each
+    end
+  end
+
+  def reverse_each
+    if block_given?
+      @observations.sort_by! { |o| o.sort_key } unless @sorted
+      @sorted = true
+      @observations.reverse_each do |o|
+        yield o
+      end
+    else
+      to_enum :reverse_each
+    end
+  end
+
+  def count
+    @observations.size
+  end
+
+  def to_list lister = Listers::SPECIES, sorter: nil
+    List::new self, lister, sorter: sorter, time: @time
+  end
+
+  def include? observation
+    @by_id.has_key? observation.id
+  end
+
+  def empty?
+    @observations.empty?
+  end
+
+  def where &block
+    raise ArgumentError, "Block must be provided!", caller unless block_given?
+    DataSet::new nil, @observations.select(&block), time: @time
+  end
+
+  alias :=== :include?
+
+  def << observation
+    raise TypeError, "Argument must be an Observation (#{ observation.inspect })!" unless Observation === observation
+    if !self.include?(observation)
+      @observations << observation
+      @by_id[observation.id] = observation
+      @sorted = false
+    end
+  end
+
+  def | other
+    obj = @object == other.object ? @object : nil
+    DataSet::new obj, @observations + other.observations, time: Time::new
+  end
+
+  def & other
+    obj = @object == other.object ? @object : nil
+    DataSet::new obj, @observations.select { |o| other.include?(o) }, time: Time::new
+  end
+
+  def - other
+    obj = @object == other.object ? @object : nil
+    DataSet::new obj, @observations.select { |o| !other.include?(o) }, time: Time::new
+  end
+
+  def to_a
+    @observations.dup
+  end
+
+end

data/lib/inat/data/sets/list.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+autoload :DataSet, 'inat/data/sets/dataset'
+
+class List
+
+  attr_reader :lister, :sorter
+
+  DEFAULT_SORTER = lambda { |ds| ds.object.respond_to?(:sort_key) ? ds.object.sort_key : ds.object }
+
+  def initialize source, lister, sorter: nil, time: Time::new
+    @lister = lister
+    @sorter = sorter || DEFAULT_SORTER
+    @time = time
+    @data = {}
+    source.each do |observation|
+      key = @lister.call observation
+      if key != nil
+        @data[key] ||= DataSet::new key, [], time: @time
+        @data[key] << observation
+      end
+    end
+  end
+
+  def self.zero lister = Listers::SPECIES
+    new [], lister
+  end
+
+  include Enumerable
+
+  def [] key
+    @data[key]
+  end
+
+  def each
+    if block_given?
+      @data.values.sort_by { |ds| @sorter.call(ds) }.each do |ds|
+        yield ds
+      end
+    else
+      to_enum :each
+    end
+  end
+
+  def to_dataset
+    observations = []
+    @data.values.each do |ds|
+      observations += ds.observations
+    end
+    DataSet::new nil, observations, time: @time
+  end
+
+  def include? key
+    @data.has_key? key
+  end
+
+  def empty?
+    @data.empty?
+  end
+
+  def count
+    @data.size
+  end
+
+  def observation_count
+    @data.values.map { |ds| ds.count }.sum
+  end
+
+  def where &block
+    raise ArgumentError, "Block must be provided!", caller unless block_given?
+    result = List::new [], @lister, sorter: @sorter, time: @time
+    self.each do |ds|
+      result << ds if yield(ds)
+    end
+    result
+  end
+
+  def << some
+    case some
+    when Observation
+      key = @lister.call some
+      if key != nil
+        @data[key] ||= DataSet::new key, [], time: @time
+        @data[key] << some
+      end
+    when DataSet
+      if !some.empty?
+        valid = some.object != nil && some.all? { |o| @lister.call(o) == some.object }
+        if valid
+          if @data[some.object]
+            @data[some.object] = @data[some.object] | some
+          else
+            @data[some.object] = some
+          end
+        else
+          some.each do |o|
+            self << o
+          end
+        end
+      end
+    when Array
+      some.each do |o|
+        self << o
+      end
+    else
+      raise TypeError, "Can not add this object: #{ some.inspect }!", caller
+    end
+  end
+
+  alias :=== :include?
+
+  def cover? other
+    other.any? { |ds| self.include?(ds.object) }
+  end
+
+  include Comparable
+
+  def <=> other
+    return nil unless List === other
+    if self.cover?(other)
+      if other.cover?(self)
+        return 0
+      else
+        return 1
+      end
+    else
+      if other.cover?(self)
+        return -1
+      else
+        return nil
+      end
+    end
+  end
+
+  def apply! *data
+    @lister, @sorter, @time, @data = data
+    self
+  end
+
+  def clone
+    List::zero.apply! @lister, @sorter, @time, @data.dup
+  end
+
+  def add! other
+    other.each do |ds|
+      self << ds
+    end
+    self
+  end
+
+  def mul! other
+    @data.delete_if { | key, _ | !other.include?(key) }
+    other.each do |ds|
+      if self.include?(ds.object)
+        self << ds
+      end
+    end
+    self
+  end
+
+  def sub! other
+    @data.delete_if { | key, _ | other.include?(key) }
+    self
+  end
+
+  def add other
+    clone.add! other
+  end
+
+  def mul other
+    # А вот здесь будет эффективней старое решение
+    result = List::new [], @lister, sorter: @sorter, time: @time
+    @data.each do |key, ds|
+      if other.include?(key)
+        summa = ds | other[key]
+        self << summa
+      end
+    end
+    result
+  end
+
+  def sub other
+    clone.sub! other
+  end
+
+  alias :+ :add
+  alias :* :mul
+  alias :- :sub
+
+end

data/lib/inat/data/sets/listers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'wrappers'
+
+module Listers
+
+  SPECIES = lambda { |o| o.normalized_taxon(Rank::COMPLEX .. Rank::HYBRID)  }
+  GENUS   = lambda { |o| o.normalized_taxon(Rank::GENUS)                    }
+  FAMILY  = lambda { |o| o.normalized_taxon(Rank::FAMILY)                   }
+  YEAR    = lambda { |o| Year[o.observed_on]                                }
+  MONTH   = lambda { |o| Month[o.observed_on]                               }
+  DAY     = lambda { |o| Day[o.observed_on]                                 }
+  USER    = lambda { |o| o.user                                             }
+
+end

data/lib/inat/data/sets/wrappers.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'date'
+
+class Year
+
+  class << self
+
+    private :new
+
+    def [] source
+      return nil if source == nil
+      return source if Year === source
+      year = case source
+      when Date, Time
+        source.year
+      when String
+        date = Date::parse source
+        date.year
+      when Integer
+        source
+      else
+        raise TypeError, "Invalid year key: #{ source.inspect }!", caller
+      end
+      @years ||= {}
+      @years[year] ||= new year
+      @years[year]
+    end
+
+  end
+
+  attr_reader :year
+
+  def initialize year
+    @year = year
+  end
+
+  include Comparable
+
+  def <=> other
+    return nil unless Year === other
+    @year <=> other.year
+  end
+
+  def - num
+    self.class[@year - num]
+  end
+
+  def to_s
+    "<i class=\"glyphicon glyphicon-calendar\"></i>  #{ @year }"
+  end
+
+end
+
+class Month
+
+  class << self
+
+    private :new
+
+    def [] source
+      return nil if source == nil
+      return source if Month === source
+      month = case source
+      when Date, Time
+        source.month
+      when String
+        date = Date::parse source
+        date.month
+      when Integer
+        source
+      else
+        raise TypeError, "Invalid month key: #{ source.inspect }!", caller
+      end
+      @months ||= {}
+      @months[month] ||= new month
+      @months[month]
+    end
+
+  end
+
+  attr_reader :month
+
+  def initialize month
+    @month = month
+  end
+
+  include Comparable
+
+  def <=> other
+    return nil unless Month === other
+    @month <=> other.month
+  end
+
+end
+
+class Day
+
+  class << self
+
+    attr_reader :day
+
+    def [] source
+      return nil if source == nil
+      return source if Day === source
+      day = case source
+      when Date, Time
+        source.day
+      when String
+        date = Date::parse source
+        date.day
+      when Integer
+        source
+      else
+        raise TypeError, "Invalid day key: #{ source.inspect }!", caller
+      end
+      @days ||= {}
+      @days[day] ||= new day
+      @days[day]
+    end
+
+  end
+
+  attr_reader :day
+
+  def initialize day
+    @day = day
+  end
+
+  include Comparable
+
+  def <=> other
+    return nil unless Day === other
+    @day <=> other.day
+  end
+
+end

data/lib/inat/data/types/extras.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'extra/enum'
+require 'extra/uuid'
+
+class Enum
+
+  class << self
+
+    pre_verbose = $VERBOSE
+    $VERBOSE = nil
+
+    alias :old_parse :parse
+
+    def parse src
+      return nil if src == nil
+      return src if self === src
+      case src
+      when Integer, Symbol
+        self[src]
+      when String
+        self.old_parse src, case_sensitive: false
+      end
+    end
+
+    $VERBOSE = pre_verbose
+
+    def ddl
+      if any? { |v| Integer === v.data }
+        {
+          name: :TEXT,
+          data: :INTEGER
+        }
+      else
+        :TEXT
+      end
+    end
+
+    def from_db src
+      return nil if src == nil
+      return self[src.intern] if String === src || Symbol === src
+      name = src[:name]&.intern
+      return nil if name == nil
+      self[name]
+    end
+
+  end
+
+  def to_db
+    if self.class.any? { |v| Integer === v.data }
+      {
+        name: name.to_s,
+        data: data
+      }
+    else
+      name.to_s
+    end
+  end
+
+  def to_query
+    to_s
+  end
+
+end
+
+class UUID
+
+  class << self
+
+    def ddl
+      :TEXT
+    end
+
+    def from_db src
+      parse src
+    end
+
+  end
+
+  def to_db
+    to_s
+  end
+
+  def to_query
+    to_s
+  end
+
+end

data/lib/inat/data/types/location.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+class Location
+
+  class << self
+
+    def parse src
+      case src
+      when nil
+        nil
+      when String
+        parse src.split(',').map(&:to_f)
+      when Array
+        new(src[0], src[1]).freeze
+      when Hash
+        latitude = src[:latitude] || src['latitude']
+        longitude = src[:longitude] || src['longitude']
+        return nil if latitude == nil && longitude == nil
+        new(latitude, longitude).freeze
+      else
+        raise ArgumentError, "Source must be a String or Array or Hash!", caller
+      end
+    end
+
+    def from_db src
+      new(src[:latitude] || src['latitude'], src[:longitude] || src['longitude']).freeze
+    end
+
+    def ddl
+      {
+        latitude: :REAL,
+        longitude: :REAL
+      }
+    end
+
+  end
+
+  attr_reader :latitude, :longitude
+
+  def initialize latitude, longitude
+    raise ArgumentError, "Latitude must be a Numeric!", caller  unless Numeric === latitude  || latitude == nil
+    raise ArgumentError, "Longitude must be a Numeric!", caller unless Numeric === longitude || latitude == nil
+    @latitude = latitude
+    @longitude = longitude
+  end
+
+  def to_db
+    {
+      latitude: latitude,
+      longitude: longitude
+    }
+  end
+
+end
+
+class Radius
+
+  attr_reader :latitude, :longitude, :radius
+
+  def initialize latitude, longitude, radius
+    raise ArgumentError, "Latitude must be a Numeric!", caller  unless Numeric === latitude
+    raise ArgumentError, "Longitude must be a Numeric!", caller unless Numeric === longitude
+    raise ArgumentError, "Radius must be a Numeric!", caller    unless Numeric === radius    || radius == nil
+    @latitude, @longitude, @radius = latitude, longitude, radius
+  end
+
+end
+
+class Sector
+
+  attr_reader :north, :east, :south, :west
+
+  def initialize north, east, south, west
+    raise ArgumentError, "North must be a Numeric!", caller unless Numeric === north
+    raise ArgumentError, "East must be a Numeric!", caller  unless Numeric === east
+    raise ArgumentError, "South must be a Numeric!", caller unless Numeric === south
+    raise ArgumentError, "West must be a Numeric!", caller  unless Numeric === west
+    @north, @east, @south, @west = north, east, south, west
+  end
+
+end
+
+def radius latitude, longitude, radius
+  Radius::new latitude, longitude, radius
+end
+
+def sector north, east, south, west
+  Sector::new north, east, south, west
+end