mayu 0.1.0.beta1

data/lib/mayu/loader.rb

@@ -0,0 +1,168 @@
+require 'mayu/association'
+require 'mayu/user'
+require 'mayu/device'
+require 'mayu/map'
+require 'mayu/ap'
+
+require 'mayu/user_completer'
+
+module Mayu
+  class Loader
+    def initialize(store:, user_completer: nil)
+      @store = store
+      @cached_user_completer = user_completer
+    end
+
+    attr_reader :store
+
+    def load
+      objects
+      self
+    end
+
+    def objects
+      @objects ||= store.get
+    end
+
+    ###
+
+    def associations
+      @associations ||= objects.fetch(:associations).map do |_|
+        Association.load(_).tap do |association|
+          association._ap_finder = method(:find_ap)
+          association._user_finder = method(:find_user)
+          association._device_finder = method(:find_device_by_mac)
+          association._ensure_relation_finders_satisfied!
+        end
+      end
+    end
+
+    def association_by_mac
+      @association_by_mac = associations.map do |_|
+        [_.mac, _]
+      end.to_h
+    end
+
+    def association_by_ip
+      @association_by_ip = associations.map do |_|
+        [_.ip, _]
+      end.to_h
+    end
+
+    def associations_by_ap
+      @association_by_ap = associations.group_by do |_|
+        _.ap_key.to_s
+      end.to_h
+    end
+
+    def find_association_by_mac(mac)
+      association_by_mac[mac]
+    end
+
+    def find_association_by_ip(ip)
+      association_by_ip[ip]
+    end
+
+    def find_associations_by_ap(k)
+      associations_by_ap.fetch(k.to_s, [])
+    end
+
+    ###
+
+    def users
+      @users ||= objects.fetch(:users).map do |_|
+        User.load(_).tap do |user|
+          user._devices_finder = method(:find_devices_by_user)
+          user._ensure_relation_finders_satisfied!
+        end
+      end
+    end
+
+    def user_by_key
+      @user_by_key ||= users.map do |_|
+        [_.key.to_sym, _]
+      end.to_h
+    end
+
+    def find_user(k)
+      user_by_key[k.to_sym]
+    end
+
+    def user_completer
+      @user_completer ||= @cached_user_completer ? @cached_user_completer.update(users) : UserCompleter.new(users)
+    end
+
+    def suggest_users(query)
+      user_completer.query(query)
+    end
+
+    ###
+
+    def devices
+      @devices ||= objects.fetch(:devices).map do |_|
+        Device.load(_).tap do |device|
+          device._user_finder = method(:find_user)
+          device._association_finder = proc { find_association_by_mac(device.mac) }
+          device._ensure_relation_finders_satisfied!
+        end
+      end
+    end
+
+    def device_by_mac
+      @device_by_mac ||= devices.reverse_each.map do |device|
+        [device.mac, device]
+      end.to_h
+    end
+
+    def devices_by_user
+      @devices_by_user ||= devices.reverse_each.group_by do |device|
+        device.user_key
+      end
+    end
+
+    def find_device_by_mac(k)
+      device_by_mac[k]
+    end
+
+    def find_devices_by_user(k)
+      devices_by_user.fetch(k, [])
+    end
+
+    ###
+
+    def maps
+      @maps ||= objects.fetch(:maps).map do |k, v|
+        [k, Map.load(v).tap do |map|
+          map.key = k
+          map._aps_finder = proc { find_aps_by_map(k).values }
+          map._ensure_relation_finders_satisfied!
+        end]
+      end.to_h
+    end
+
+    def find_map(k)
+      maps[k.to_sym]
+    end
+
+    ###
+
+    def aps
+      @aps ||= objects.fetch(:aps).map do |k,v|
+        [k, Ap.load(v).tap do |ap|
+          ap.key = k
+          ap._map_finder = method(:find_map)
+          ap._associations_finder = proc { find_associations_by_ap(k) }
+          ap._ensure_relation_finders_satisfied!
+        end]
+      end.to_h
+    end
+
+    def find_ap(k)
+      aps[k.to_sym]
+    end
+
+    def find_aps_by_map(key)
+      aps.select { |k,v| v.map_key.to_s == key.to_s }
+    end
+  end
+end

data/lib/mayu/map.rb

@@ -0,0 +1,42 @@
+module Mayu
+  Map = Struct.new(:key, :name, :url, :fg_color, :bg_color, :highlight_color, keyword_init: true) do
+    include Mayu::Relation
+
+    def self.load(obj)
+      new(**obj)
+    end
+
+    relates :aps
+
+    def associations
+      @associations ||= aps.flat_map(&:associations)
+    end
+    def devices
+      @devices ||= aps.flat_map(&:devices)
+    end
+    def users
+      @users ||= aps.flat_map(&:users)
+    end
+
+    def associations_count
+      associations.size
+    end
+    def devices_count
+      devices.size
+    end
+    def users_count
+      users.size
+    end
+
+    def as_json
+      {
+        key: key,
+        name: name,
+        url: url,
+        fg_color: fg_color,
+        bg_color: bg_color,
+        highlight_color: highlight_color,
+      }
+    end
+  end
+end

data/lib/mayu/periodic_loader.rb

@@ -0,0 +1,55 @@
+require 'mayu/loader'
+require 'thread'
+
+module Mayu
+  class PeriodicLoader
+    SHUTDOWN_KEY = :mayu_periodic_loader_shutdown
+    def initialize(interval:, **options)
+      @loaded_at = nil
+      @loader = nil
+      @interval = interval
+      @options = options
+      @lock = Mutex.new
+      @thread = nil
+    end
+
+    attr_reader :loaded_at, :loader
+
+    def start
+      return if @thread
+      @lock.synchronize do
+        return if @thread
+        reload
+        @thread = Thread.new(&method(:thread))
+      end
+    end
+
+    def shutdown
+      @lock.synchronize do
+        if @thread
+          @thread[SHUTDOWN_KEY] = true
+        end
+        @thread = nil
+      end
+    end
+
+    def reload
+      @loaded_at = Time.now
+      new_loader = Loader.new(user_completer: @loader&.user_completer, **@options).load
+      @loader = new_loader
+    end
+
+    def thread
+      loop do
+        return if @thread[SHUTDOWN_KEY]
+        @lock.synchronize do
+          reload
+        end
+        sleep @interval
+      rescue Exception => e
+        $stderr.puts e.full_message
+        sleep @interval
+      end
+    end
+  end
+end

data/lib/mayu/relation.rb

@@ -0,0 +1,50 @@
+module Mayu
+  module Relation
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def _ensure_relation_finders_satisfied!
+      self.class.relations.map do |k|
+        unless instance_variable_get(:"@_#{k}_finder")
+          raise "#{k.class}: #{k.inspect} not satisfied"
+        end
+      end
+    end
+
+    module ClassMethods
+      def relations
+        @_relations ||= []
+      end
+      def relates(name)
+        self.relations << name
+
+        key_exist = self.instance_methods.include?(:"#{name}_key")
+        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+          def _#{name}_finder=(x)
+            @_#{name}_finder = x
+          end
+
+          def _#{name}
+            @_#{name}
+          end
+
+          def _#{name}=(x)
+            key = #{key_exist ? "#{name}_key" : 'nil'}
+            @_#{name}_key = key
+            @_#{name} = x
+          end
+
+          def #{name}
+            raise "#{name} finder not set" unless @_#{name}_finder
+            key = #{key_exist ? "#{name}_key" : 'nil'}
+            if @_#{name}_key && @_#{name}_key != key
+              @_#{name} = nil
+            end
+            self._#{name} ||= @_#{name}_finder[key]
+          end
+        EOF
+      end
+    end
+  end
+end

data/lib/mayu/renderer.rb

@@ -0,0 +1,43 @@
+require 'json'
+
+module Mayu
+
+  class Renderer
+    def initialize(spec)
+      @spec = spec
+    end
+
+    def render(obj, spec: @spec)
+      r = nil
+      case obj
+      when nil
+        return nil
+      when Array
+        return obj.map { |_| render(_, spec: spec) }
+      when Hash
+        r = obj
+      else
+        case
+        when obj.respond_to?(:as_json)
+          r = obj.as_json
+        when !spec.empty?
+          r = {}
+        else
+          return obj
+        end
+      end
+      next_specs, keys = [spec].flatten.partition { |_| Hash === _ }
+      aref = Hash === obj
+      r2 = r.transform_values do |v|
+        render(v, spec: {})
+      end
+      keys.each do |k|
+        r[k] = render(r.fetch(k) { aref ? obj.fetch(k) { obj.send(k) } : obj.send(k) }, spec: {})
+      end
+      (next_specs.inject(&:merge) || {}).each do |k, ns|
+        r[k] = render(r.fetch(k) { aref ? obj.fetch(k) { obj.send(k) } : obj.send(k) }, spec: ns)
+      end
+      r2.merge(r)
+    end
+  end
+end

data/lib/mayu/stores/base.rb

@@ -0,0 +1,44 @@
+require 'time'
+module Mayu
+  module Stores
+    class Base
+      def initialize(**options)
+        @options = options
+      end
+
+      def put(obj)
+        raise NotImplementedError
+      end
+
+      def get
+        raise NotImplementedError
+      end
+
+      def for_json(obj)
+        case obj
+        when Array
+          obj.map{ |_| for_json(_) }
+        when Hash
+          obj.transform_values { |v| v.is_a?(Time) ? v.xmlschema : for_json(v) }
+        else
+          obj
+        end
+      end
+
+      def from_json(obj)
+        case obj
+        when Array
+          obj.map do |v|
+            from_json(v)
+          end
+        when Hash
+          obj.map do |k,v|
+            [k, k.to_s.end_with?('_at') ? (v && Time.xmlschema(v)) : from_json(v)]
+          end.to_h
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/mayu/stores/concat.rb

@@ -0,0 +1,41 @@
+require 'mayu/stores/base'
+
+module Mayu
+  module Stores
+    class Concat < Base
+      def initialize(stores:)
+        @stores = stores
+      end
+
+      attr_reader :stores
+
+      def put(obj)
+        raise NotImplementedError, "this store is read only"
+      end
+
+      def get
+        objs = @stores.map(&:get)
+        keys = objs.flat_map(&:keys).uniq
+
+        r = {}
+        objs.each do |i|
+          keys.each do |k|
+            next unless i[k]
+            case r[k]
+            when Array
+              r[k] ||= []
+              r[k] += i[k]
+            when Hash
+              r[k] ||= {}
+              r[k] = r[k].merge(i[k])
+            else
+              r[k] = i[k]
+            end
+          end
+        end
+        r
+      end
+    end
+  end
+end
+