hyper-operation 1.0.alpha1.8 → 1.0.0.lap28

data/lib/hyper-operation/transport/connection_adapter/redis/redis_record.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-module Hyperstack
-  module ConnectionAdapter
-    module Redis
-      module RedisRecord
-        class Base
-          class << self
-            attr_accessor :table_name, :column_names
-
-            def client
-              @client ||= ::Redis.new(url: Hyperstack.connection[:redis_url])
-            end
-
-            def scope(&block)
-              ids = client.smembers(table_name)
-
-              ids = ids.map(&block) if block
-
-              ids.compact.map { |id| instantiate(id) }
-            end
-
-            def all
-              scope
-            end
-
-            def first
-              id = client.smembers(table_name).first
-
-              instantiate(id)
-            end
-
-            def last
-              id = client.smembers(table_name).last
-
-              instantiate(id)
-            end
-
-            def find(id)
-              return unless client.smembers(table_name).include?(id)
-
-              instantiate(id)
-            end
-
-            def find_by(opts)
-              found = nil
-
-              client.smembers(table_name).each do |id|
-                unless opts.map { |k, v| get_dejsonized_attribute(id, k) == v }.include?(false)
-                  found = instantiate(id)
-                  break
-                end
-              end
-
-              found
-            end
-
-            def find_or_create_by(opts = {})
-              if (existing = find_by(opts))
-                existing
-              else
-                create(opts)
-              end
-            end
-
-            def where(opts = {})
-              scope do |id|
-                unless opts.map { |k, v| get_dejsonized_attribute(id, k) == v }.include?(false)
-                  id
-                end
-              end
-            end
-
-            def exists?(opts = {})
-              !!client.smembers(table_name).detect do |id|
-                !opts.map { |k, v| get_dejsonized_attribute(id, k) == v }.include?(false)
-              end
-            end
-
-            def create(opts = {})
-              record = new({ id: SecureRandom.uuid }.merge(opts))
-
-              record.save
-
-              record
-            end
-
-            def destroy_all
-              all.each(&:destroy)
-
-              true
-            end
-
-            def jsonize_attributes(attrs)
-              attrs.map do |attr, value|
-                [attr, value.to_json]
-              end.to_h
-            end
-
-            def dejsonize_attributes(attrs)
-              attrs.map do |attr, value|
-                [attr, value && JSON.parse(value)]
-              end.to_h
-            end
-
-            protected
-
-            def instantiate(id)
-              new(dejsonize_attributes(client.hgetall("#{table_name}:#{id}")))
-            end
-
-            def get_dejsonized_attribute(id, attr)
-              value = client.hget("#{table_name}:#{id}", attr)
-              JSON.parse(value) if value
-            end
-          end
-
-          def initialize(opts = {})
-            opts.each { |k, v| send(:"#{k}=", v) }
-          end
-
-          def save
-            self.class.client.hmset("#{table_name}:#{id}", *self.class.jsonize_attributes(attributes))
-
-            unless self.class.client.smembers(table_name).include?(id)
-              self.class.client.sadd(table_name, id)
-            end
-
-            true
-          end
-
-          def update(opts = {})
-            opts.each { |k, v| send(:"#{k}=", v) }
-            save
-          end
-
-          def destroy
-            self.class.client.srem(table_name, id)
-
-            self.class.client.hdel("#{table_name}:#{id}", attributes.keys)
-
-            true
-          end
-
-          def attributes
-            self.class.column_names.map do |column_name|
-              [column_name, instance_variable_get("@#{column_name}")]
-            end.to_h
-          end
-
-          def table_name
-            self.class.table_name
-          end
-        end
-      end
-    end
-  end
-end

data/lib/hyper-operation/transport/policy_diagnostics.rb

@@ -1,106 +0,0 @@
-module Hyperstack
-  class ClassConnectionRegulation
-    def self.connections(acting_user)
-      regulations.collect do |channel, regulation|
-        status = regulation.connectable?(acting_user) ? :allowed : :denied
-        { type: :class, owner: channel, channel: InternalPolicy.channel_to_string(channel), auto_connect: !regulation.auto_connect_disabled?, status: status }
-      end
-    end
-  end
-
-  class InstanceConnectionRegulation
-    def self.connections(acting_user)
-      regulations.collect do |channel, regulation|
-        regulation.connectable_to(acting_user, false).collect do |obj|
-          { type: :instance, owner: channel, channel: InternalPolicy.channel_to_string(obj), auto_connect: !regulation.auto_connect_disabled?, status: :allowed }
-        end
-      end.flatten(1)
-    end
-  end
-
-  class InternalPolicy
-    def attribute_dump(acting_user)
-      # dump[channel]['@channel_status'] -> [owner, type, auto_connect, falsy/no connection/allowed]
-      # dump[channel][attribute] -> 'no connection/no channel/no policy/allowed'
-      dump = Hash.new { |h, k| h[k] = Hash.new }
-      connections = ClassConnectionRegulation.connections(acting_user) +
-                    InstanceConnectionRegulation.connections(acting_user)
-      connections.each do |status|
-        status[:status] = 'allowed' if status[:status]
-        status[:status] ||= 'no connection'
-        dump[status[:channel]]['@channel_status'] = status
-      end
-      @channel_sets.each do |channel, attribute_set|
-        channel = InternalPolicy.channel_to_string(channel)
-        attribute_set.each do |attribute|
-          dump[channel]['@channel_status'] ||= { type: 'no channel' }
-          dump[channel][attribute] = dump[channel]['@channel_status'][:status] || 'no channel'
-        end
-      end
-      dump.each_key do |channel|
-        @attribute_names.each do |attribute|
-          dump[channel][attribute] ||= 'no policy'
-        end
-      end
-      dump
-    end
-  end
-
-  module PolicyDiagnostics
-    def self.policy_dump_hash(model, acting_user)
-      internal_policy = InternalPolicy.new(model, model.attribute_names, :all)
-      ChannelBroadcastRegulation.broadcast(internal_policy)
-      InstanceBroadcastRegulation.broadcast(model, internal_policy)
-      internal_policy.attribute_dump(acting_user)
-    end
-
-    def self.policy_dump_for(model, acting_user)
-      dump = policy_dump_hash(model, acting_user)
-      attributes = model.attribute_names.map(&:to_sym)
-      acting_user_channel = InternalPolicy.channel_to_string(acting_user) if acting_user
-      pastel = Pastel.new
-      channels = dump.keys.collect do |channel|
-        c = channel == acting_user_channel ? "* #{channel} *" : channel
-        if dump[channel]['@channel_status'][:status] != 'allowed'
-          pastel.red(c)
-        elsif channel == acting_user_channel
-          pastel.blue(c)
-        else
-          c
-        end
-      end
-      table = TTY::Table.new header: [''] + channels
-      types = dump.keys.collect do |channel|
-        type = dump[channel]['@channel_status'][:type]
-        type = pastel.red(type) if type == 'no policy'
-        type
-      end
-      table << ['type'] + types
-      table << ['auto connect'] + dump.keys.collect { |channel| dump[channel]['@channel_status'][:auto_connect] }
-      table << ['status'] + dump.keys.collect { |channel| dump[channel]['@channel_status'][:status] }
-      attributes.each do |attribute|
-        allowed = false
-        statuses = dump.keys.collect do |channel|
-          status = dump[channel][attribute]
-          if status == 'allowed'
-            allowed = true
-            status
-          else
-            pastel.red(status)
-          end
-        end
-        attribute = pastel.red(attribute) unless allowed
-        table << [attribute] + statuses
-      end
-      rendered = table.render(:unicode, indent: 4).split("\n")
-      rendered = rendered.insert(6, rendered[2]).join("\n")
-      model_string = "<##{model.class} id: #{model.id}>"
-      if acting_user
-        id = "id: #{acting_user.id}" if acting_user.respond_to? :id
-        acting_user_string = "by acting_user <##{acting_user.class} id: #{id}>"
-      end
-      "    Attribute access policies for #{model_string} #{acting_user_string || 'with no acting_user'}:\n\n"\
-      "#{rendered}"
-    end
-  end
-end