inat-get 0.8.0.11 → 0.8.0.13

data/lib/inat/data/model.rb

@@ -3,12 +3,17 @@
 require_relative '../app/globals'
 require_relative 'types/std'
 
-autoload :Entity, 'inat/data/entity'
+module INat::Data
+  autoload :Entity, 'inat/data/entity'
+end
+
+module INat::Data; end
 
-class Model
+class INat::Data::Model
 
-  include LogDSL
+  include INat::App::Logger::DSL
 
+  # @private
   class Field
 
     attr_reader :model, :name, :type, :id_field
@@ -42,7 +47,10 @@ class Model
 
   end
 
-  class ScalarField < Model::Field
+  # @private
+  class ScalarField < Field
+
+    using INat::Types::Std
 
     attr_reader :index, :unique, :primary_key
 
@@ -51,7 +59,7 @@ class Model
     end
 
     def initialize model, name, type, id_field, required, index, unique, primary_key
-      if Class === type && Entity > type && id_field == nil
+      if Class === type && INat::Data::Entity > type && id_field == nil
         id_field = "#{ name }_id".intern
       end
       super model, name, type, id_field
@@ -74,7 +82,7 @@ class Model
         md.define_method "#{ ni }=" do |value|
           prevalue = instance_variable_get "@#{ ni }"
           if prevalue != value
-            debug "ASS: #{ self.id }: #{ ni } = #{ prevalue.inspect } <=> #{ value.inspect }" if prevalue != nil && self.class.name == 'Taxon'
+            debug "ASS: #{ self.id }: #{ ni } = #{ prevalue.inspect } <=> #{ value.inspect }" if prevalue != nil && self.class.short_name == 'Taxon'
             instance_variable_set "@#{ ni }", value
             instance_variable_set "@saved", false
           end
@@ -92,7 +100,7 @@ class Model
         md.define_method "#{ nm }=" do |value|
           prevalue = instance_variable_get "@#{ ni }"
           if prevalue != value&.id
-            debug "ASS: #{ self.id }: #{ nm } / #{ ni } = #{ prevalue.inspect } <=> #{ value.inspect }" if prevalue != nil && self.class.name == 'Taxon'
+            debug "ASS: #{ self.id }: #{ nm } / #{ ni } = #{ prevalue.inspect } <=> #{ value.inspect }" if prevalue != nil && self.class.short_name == 'Taxon'
             instance_variable_set "@#{ ni }", value&.id
             instance_variable_set "@saved", false
           end
@@ -105,7 +113,7 @@ class Model
           raise TypeError, "Invalid '#{ nm }' value: #{ value.inspect }!", caller unless tp === value || (value == nil && !rq)
           prevalue = instance_variable_get "@#{ nm }"
           if prevalue != value
-            debug "ASS: #{ self.id }: #{ nm } = #{ prevalue.inspect } <=> #{ value.inspect }" if prevalue != nil && self.class.name == 'Taxon'
+            debug "ASS: #{ self.id }: #{ nm } = #{ prevalue.inspect } <=> #{ value.inspect }" if prevalue != nil && self.class.short_name == 'Taxon'
             instance_variable_set "@#{ nm }", value
             instance_variable_set "@saved", false
           end
@@ -207,7 +215,10 @@ class Model
 
   end
 
-  class ArrayField < Model::Field
+  # @private
+  class ArrayField < Field
+
+    using INat::Types::Std
 
     attr_reader :back_field
 
@@ -223,7 +234,7 @@ class Model
           raise ArgumentError, "Argument 'id_field' is required for name '#{ name }'!", caller[1..]
         end
       end
-      back_field = "#{ model.name.downcase }_id".intern if back_field == nil
+      back_field = "#{ model.short_name.downcase }_id".intern if back_field == nil
       super model, name, type, id_field
       @owned = owned
       @back_field = back_field
@@ -248,7 +259,7 @@ class Model
             value = value&.sort.uniq
           end
           if prevalue != value
-            debug "ASS: #{ self.id }: #{ ni } = #{ prevalue.inspect } <=> #{ value.inspect } :: #{ caller[..2] }" if prevalue != nil && self.class.name == 'Taxon'
+            debug "ASS: #{ self.id }: #{ ni } = #{ prevalue.inspect } <=> #{ value.inspect } :: #{ caller[..2] }" if prevalue != nil && self.class.short_name == 'Taxon'
             instance_variable_set "@#{ ni }", value
             instance_variable_set "@saved", false
           end
@@ -274,7 +285,7 @@ class Model
           end
           prevalue = instance_variable_get("@#{ nm }")
           if prevalue&.sort != value&.sort
-            debug "ASS: #{ self.id }: #{ nm } = #{ prevalue.inspect } <=> #{ value.inspect } :: #{ caller[..2] }" if prevalue != nil && self.class.name == 'Taxon'
+            debug "ASS: #{ self.id }: #{ nm } = #{ prevalue.inspect } <=> #{ value.inspect } :: #{ caller[..2] }" if prevalue != nil && self.class.short_name == 'Taxon'
             instance_variable_set "@#{ nm }", value
             instance_variable_set "@saved", false
           end
@@ -292,13 +303,16 @@ class Model
 
   end
 
-  class ManyToManyField < Model::ArrayField
+  # @private
+  class ManyToManyField < ArrayField
+
+    using INat::Types::Std
 
     attr_reader :table_name, :link_field, :index
 
     def initialize model, name, type, id_field, owned, table_name, back_field, link_field, index
-      table_name = "#{ model.name.downcase }_#{ name }".intern if table_name == nil
-      link_field = "#{ type.name.downcase }_id".intern         if link_field == nil
+      table_name = "#{ model.short_name.downcase }_#{ name }".intern if table_name == nil
+      link_field = "#{ type.short_name.downcase }_id".intern         if link_field == nil
       super model, name, type, id_field, owned, back_field
       @table_name = table_name
       @link_field = link_field
@@ -327,7 +341,8 @@ class Model
 
   end
 
-  class OneToManyField < Model::ArrayField
+  # @private
+  class OneToManyField < ArrayField
 
     def kind
       :backs
@@ -335,7 +350,8 @@ class Model
 
   end
 
-  class SpecialField < Model::Field
+  # @private
+  class SpecialField < Field
 
     def initialize model, name, type, &block
       raise ArgumentError, "Block is required!", caller[1..] unless block_given?
@@ -359,7 +375,8 @@ class Model
 
   end
 
-  class IgnoreField < Model::SpecialField
+  # @private
+  class IgnoreField < SpecialField
 
     def initialize model, name
       super model, name, Object do
@@ -433,7 +450,15 @@ class Model
       result.freeze
     end
 
-    private def field name, type: nil, id_field: nil, required: false, index: false, unique: false, primary_key: false
+    # Defines a new field
+    # @param [Symbol] name
+    # @param [Class] type
+    # @return [void]
+    # @!macro [attach] field
+    #   @api public
+    #   @!attribute [rw]
+    #   @return [$2] the +$1+ field
+    def field name, type: nil, id_field: nil, required: false, index: false, unique: false, primary_key: false
       raise TypeError, "Field name must be a Symbol!", caller              unless Symbol === name
       raise TypeError, "Field type must be a Module!", caller              unless Module === type
       raise TypeError, "Argument 'id_field' must be a Symbol!", caller     unless Symbol === id_field || id_field == nil
@@ -446,9 +471,17 @@ class Model
       @fields[name].implement
     end
 
-    private def links name, item_type: nil, ids_field: nil, owned: true, table_name: nil, back_field: nil, link_field: nil, index: false
+    # Defines a new many-to-many field
+    # @param [Symbol] name
+    # @param [Class] item_type
+    # @return [void]
+    # @!macro [attach] links
+    #   @api public
+    #   @!attribute [rw]
+    #   @return [Array<$2>] the +$1+ field
+    def links name, item_type: nil, ids_field: nil, owned: true, table_name: nil, back_field: nil, link_field: nil, index: false
       raise TypeError, "Field name must be a Symbol!", caller            unless Symbol === name
-      raise TypeError, "Item type must be an Entity subclass!", caller   unless Class === item_type && Entity > item_type
+      raise TypeError, "Item type must be an Entity subclass!", caller   unless Class === item_type && INat::Entity > item_type
       raise TypeError, "Argument 'ids_field' must be a Symbol!", caller  unless Symbol === ids_field || ids_field == nil
       raise TypeError, "Argument 'table_name' must be a Symbol!", caller unless Symbol === table_name || table_name == nil
       raise TypeError, "Argument 'back_field' must be a Symbol!", caller unless Symbol === back_field || back_field == nil
@@ -460,9 +493,17 @@ class Model
       @fields[name].implement
     end
 
-    private def backs name, item_type: nil, ids_field: nil, owned: true, back_field: nil
+    # Defines a new one-to-many field
+    # @param [Symbol] name
+    # @param [Class] item_type
+    # @return [void]
+    # @!macro [attach] backs
+    #   @api public
+    #   @!attribute [rw]
+    #   @return [Array<$2>] the +$1+ field
+    def backs name, item_type: nil, ids_field: nil, owned: true, back_field: nil
       raise TypeError, "Field name must be a Symbol!", caller            unless Symbol === name
-      raise TypeError, "Item type must be an Entity subclass!", caller   unless Class === item_type && Entity > item_type
+      raise TypeError, "Item type must be an Entity subclass!", caller   unless Class === item_type && INat::Entity > item_type
       raise TypeError, "Argument 'ids_field' must be a Symbol!", caller  unless Symbol === ids_field || ids_field == nil
       raise TypeError, "Argument 'back_field' must be a Symbol!", caller unless Symbol === back_field || back_field == nil
       raise TypeError, "Argument 'owned' must be a Boolean!", caller     unless Boolean === owned
@@ -471,7 +512,15 @@ class Model
       @fields[name].implement
     end
 
-    private def block name, type: nil, &block
+    # Defines a new write-only field
+    # @param [Symbol] name
+    # @param [Class] type
+    # @return [void]
+    # @!macro [attach] block
+    #   @api public
+    #   @!attribute [w]
+    #   @return [$2] the +$1+ field
+    def block name, type: nil, &block
       raise TypeError, "Field name must be a Symbol!", caller unless Symbol === name
       raise TypeError, "Field type must be a Module!", caller unless Module === type
       raise ArgumentError, "Block is required!", caller          unless block_given?

data/lib/inat/data/query.rb

@@ -14,9 +14,14 @@ require_relative 'types/std'
 require_relative 'types/location'
 require_relative 'types/extras'
 
-class Query
+class INat::Query
 
-  include LogDSL
+  using INat::Types::Std
+
+  include INat
+  include INat::App
+  include INat::App::Logger::DSL
+  include INat::Data::Types
 
   private def parse_accuracy value
     case value
@@ -1077,17 +1082,17 @@ class Query
         if mode != UpdateMode::MINIMAL
           actual_time = Time::new - Period::parse(G.config[:data][:update_period])
         end
-        actuals = Request::from_db_rows(DB.execute("SELECT * FROM requests WHERE time >= ?", actual_time.to_db)).select { |rq| self.in?(rq.query) }
+        actuals = Entity::Request::from_db_rows(DB.execute("SELECT * FROM requests WHERE time >= ?", actual_time.to_db)).select { |rq| self.in?(rq.query) }
       end
       if actuals.empty? || mode == UpdateMode::FORCE
         # 2. Ищем чего бы обновить
-        request = Request::from_db_rows(DB.execute("SELECT * FROM requests WHERE query = ?", api_query)).first
+        request = Entity::Request::from_db_rows(DB.execute("SELECT * FROM requests WHERE query = ?", api_query)).first
         updated_since = nil
         if request == nil
           query_string = api_query
           project_id = @api_params[:project_id]
           project_id = nil unless Integer === project_id
-          request = Request::create query_string, project_id
+          request = Entity::Request::create query_string, project_id
           request.save
         else
           updated_since = request.time if mode != UpdateMode::RELOAD
@@ -1104,7 +1109,7 @@ class Query
           tt = nil
           cc = 0
           current_time = Time::new
-          API::query(:observations, **params) do |json, total|
+          INat::API::query(:observations, **params) do |json, total|
             tt ||= total
             cc += 1
             pc = cc * 100 / tt
@@ -1113,7 +1118,7 @@ class Query
             pe = Period::make seconds: te
             pt = Period::make seconds: (Time::new - current_time).to_i
             Status::status nil, "Query \##{ @int_key } : R\##{ request.id } : parsed #{ format("%d of %d : %3d%% : time %s remain %s", cc, tt, pc, pt.to_hs, pe.to_hs) }"
-            obs = Observation::parse json
+            obs = Entity::Observation::parse json
             obs.save
             DB.execute "INSERT OR REPLACE INTO request_observations (request_id, observation_id) VALUES (?, ?);", request.id, obs.id
           end
@@ -1123,12 +1128,12 @@ class Query
         # TODO: разобраться с удалением устаревшего
         # NEED: разобраться с частичной загрузкой — большие проекты грузятся недопустимо долго
         #       возможно, стоит запараллелить обработку
-        request = Request::read(request.id).first
+        request = Entity::Request::read(request.id).first
       end
     end
     # TODO: разобраться, где тупня
     sql, sql_args = db_where
-    result = Observation::from_db_rows(DB.execute("SELECT * FROM observations o#{ sql.empty? && '' || ' WHERE ' }#{ sql };", *sql_args))
+    result = Entity::Observation::from_db_rows(DB.execute("SELECT * FROM observations o#{ sql.empty? && '' || ' WHERE ' }#{ sql };", *sql_args))
     if !@r_match.empty?
       result = result.filter { |o| self.match?(o) }
     end

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

@@ -3,10 +3,13 @@
 require_relative 'listers'
 require_relative 'list'
 
-class DataSet
+class INat::Report::DataSet
+
+  include INat
+  include INat::Report
 
   attr_reader :time
-  attr_reader :object
+  attr_accessor :object                # TODO: переделать select так, чтобы не было необходимости во внешнем присваивании
   attr_reader :observations
 
   def initialize object, observations, time: Time::new
@@ -74,7 +77,8 @@ class DataSet
   alias :=== :include?
 
   def << observation
-    raise TypeError, "Argument must be an Observation (#{ observation.inspect })!" unless Observation === observation
+    raise TypeError, "Argument must be an Observation (#{ observation.inspect })!" unless Entity::Observation === observation
+    # TODO: добавить массивы и прочее
     if !self.include?(observation)
       @observations << observation
       @by_id[observation.id] = observation
@@ -84,17 +88,17 @@ class DataSet
 
   def | other
     obj = @object == other.object ? @object : nil
-    DataSet::new obj, @observations + other.observations, time: Time::new
+    INat::Report::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
+    INat::Report::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
+    INat::Report::DataSet::new obj, @observations.select { |o| !other.include?(o) }, time: Time::new
   end
 
   def to_a

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

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
-autoload :DataSet, 'inat/data/sets/dataset'
+module INat::Report
+  autoload :DataSet, 'inat/data/sets/dataset'
+end
+
+class INat::Report::List
 
-class List
+  include INat
+  include INat::Report
 
   attr_reader :lister, :sorter
 
@@ -77,7 +82,7 @@ class List
 
   def << some
     case some
-    when Observation
+    when Entity::Observation
       key = @lister.call some
       if key != nil
         @data[key] ||= DataSet::new key, [], time: @time

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

@@ -2,14 +2,20 @@
 
 require_relative 'wrappers'
 
-module Listers
+# TODO: возможно, загнать внутрь List?
+
+module INat::Report::Listers
+
+  include INat::Report
+  include INat::Data::Types
 
   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]                                 }
+  YEAR    = lambda { |o| Period::Year[o.observed_on]                        }
+  MONTH   = lambda { |o| Period::Month[o.observed_on]                       }
+  DAY     = lambda { |o| Period::Day[o.observed_on]                         }
+  WINTER  = lambda { |o| Period::Winter[o.observed_on]                      }
   USER    = lambda { |o| o.user                                             }
 
 end

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

@@ -2,136 +2,165 @@
 
 require 'date'
 
-class Year
+module INat::Report; end
+
+# TODO: переделать в модуль namespace и Base-класс отдельно
+
+class INat::Report::Period
 
   class << self
 
     private :new
 
-    def [] source
-      return nil if source == nil
-      return source if Year === source
-      year = case source
-      when Date, Time
-        source.year
+    def [] src
+      return nil if src == nil
+      return src if self === src
+      value = case src
+      when Date
+        self.date_to_value src
+      when Time
+        self.date_to_value src.to_date
       when String
-        date = Date::parse source
-        date.year
+        date = Date::parse src
+        self.date_to_value date
       when Integer
-        source
+        src
       else
-        raise TypeError, "Invalid year key: #{ source.inspect }!", caller
+        raise TypeError, "Invalid date: #{ src.inspect }", caller
       end
-      @years ||= {}
-      @years[year] ||= new year
-      @years[year]
+      return nil if value == nil
+      @values ||= {}
+      @values[value] ||= new value
+      @values[value]
     end
 
   end
 
-  attr_reader :year
+  attr_reader :value
 
-  def initialize year
-    @year = year
+  def initialize value
+    @value = value
   end
 
   include Comparable
 
   def <=> other
-    return nil unless Year === other
-    @year <=> other.year
+    return nil unless self.class === other
+    @value <=> other.value
   end
 
-  def - num
-    self.class[@year - num]
-  end
+  class Year < INat::Report::Period
 
-  def to_s
-    "<i class=\"glyphicon glyphicon-calendar\"></i>  #{ @year }"
-  end
+    class << self
 
-end
+      protected def date_to_value date
+        date.year
+      end
 
-class Month
+    end
 
-  class << self
+    alias :year :value
 
-    private :new
+    def - num
+      self.class[@value - num]
+    end
 
-    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]
+    def to_s
+      "<i class=\"glyphicon glyphicon-calendar\"></i>  #{ @value } год"
+    end
+
+    def query_params
+      "year=#{ @value }"
     end
 
   end
 
-  attr_reader :month
+  class Month < INat::Report::Period
 
-  def initialize month
-    @month = month
-  end
+    class << self
 
-  include Comparable
+      protected def date_to_value date
+        date.month
+      end
 
-  def <=> other
-    return nil unless Month === other
-    @month <=> other.month
-  end
+    end
 
-end
+    alias :month :value
+
+    NAMES = {
+      1  => 'Январь',
+      2  => 'Февраль',
+      3  => 'Март',
+      4  => 'Апрель',
+      5  => 'Май',
+      6  => 'Июнь',
+      7  => 'Июль',
+      8  => 'Август',
+      9  => 'Сентябрь',
+      10 => 'Октябрь',
+      11 => 'Ноябрь',
+      12 => 'Декабрь'
+    }
+
+    def to_s
+      "<i class=\"glyphicon glyphicon-calendar\"></i>  #{ NAMES[@value] }"
+    end
 
-class Day
+    def query_params
+      "month=#{ @value }"
+    end
 
-  class << self
+  end
 
-    attr_reader :day
+  class Day < INat::Report::Period
 
-    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
+    class << self
+
+      protected def date_to_value date
         date.day
-      when Integer
-        source
-      else
-        raise TypeError, "Invalid day key: #{ source.inspect }!", caller
       end
-      @days ||= {}
-      @days[day] ||= new day
-      @days[day]
+
     end
 
-  end
+    alias :day :value
+
+    def to_s
+      "<i class=\"glyphicon glyphicon-calendar\"></i>  #{ @value }"
+    end
 
-  attr_reader :day
+    def query_params
+      "day=#{ @value }"
+    end
 
-  def initialize day
-    @day = day
   end
 
-  include Comparable
+  class Winter < INat::Report::Period
+
+    class << self
+
+      protected def date_to_value date
+        month = date.month
+        if month <= 4
+          date.year
+        elsif month >= 10
+          date.year + 1
+        else
+          nil
+        end
+      end
+
+    end
+
+    alias :winter :value
+
+    def to_s
+      "<i class=\"glyphicon glyphicon-calendar\"></i>  Зима #{ @value - 1 }–#{ @value }"
+    end
+
+    def query_params
+      "d1=#{ @value - 1 }-10-01&d2=#{ @value }-04-30"
+    end
 
-  def <=> other
-    return nil unless Day === other
-    @day <=> other.day
   end
 
 end