slack_resources 0.0.0

data/lib/slack_resources/generator/event_api/fetch.rb

@@ -0,0 +1,111 @@
+require 'pathname'
+require 'rest-client'
+require 'nokogiri'
+require 'json'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+
+BASE_DIR = Pathname('./resources/event_api')
+EXAMPLES_DIR = BASE_DIR.join('examples')
+FileUtils.mkdir_p(EXAMPLES_DIR)
+
+def fetch(url)
+  tmp = Pathname('./tmp')
+  path = tmp.join(url.tr(':', '_').tr('/', '_')).to_s
+
+  return File.read(path) if File.exist?(path)
+
+  RestClient.get(url).tap { |data| File.write(path, data) }
+end
+
+def event_api_urls
+  base = 'https://api.slack.com/events/api'
+  doc = Nokogiri.parse(fetch(base))
+  doc.css('#api_main_content a.bold.block').map { |a| URI.join(base, a.attributes['href']).to_s }
+end
+
+def event_api_pages
+  @event_api_pages ||= event_api_urls.map do |url|
+    [url, url.split('/').pop, fetch(url)]
+  end
+end
+
+def analise(html)
+  doc = Nokogiri.parse(html)
+  [
+    pick_response(doc),
+    pick_compatibility(doc),
+    pick_scopes(doc),
+  ]
+end
+
+def pick_response(doc)
+  response_raw = doc.css('#api_main_content pre')[0].content
+  parse(response_raw)
+end
+
+def pick_compatibility(doc)
+  doc.css('#api_main_content .col.span_2_of_3.small')[0]
+     .content
+     .gsub("\t\t", "\t")
+     .split("\t")
+     .select(&:present?)[1..-1]&.
+    map(&:chomp) || []
+end
+
+def pick_scopes(doc)
+  doc.css('#api_main_content .col.span_1_of_3.small')[0]&.
+    content
+     .gsub("\t\t", "\t")
+     .split("\t")
+     .select(&:present?)[1..-1]&.
+    map(&:chomp) || []
+end
+
+def parse(json)
+  clean = json.gsub(/\{[\s\n]*…[^}]*\},?/m, '{},').gsub(/\{[\s\n]*\.\.\.[^}]*\},?/m, '{},').gsub(%("3"\n), %("3",\n))
+  JSON.parse(clean)
+rescue StandardError
+  force(clean)
+end
+
+def force(clean)
+  eval(clean)
+rescue StandardError
+  raise
+end
+
+def write_response_sample
+  types = []
+  on_event_api = []
+  on_rtm = []
+  all_scopes = []
+  subscriptions = {}
+
+  event_api_pages.each do |url, type, page|
+    response, compatibility, scopes = analise(page)
+
+    types << type
+    on_event_api << type if compatibility.include?('Events API')
+    on_rtm << type if compatibility.include?('RTM')
+
+    all_scopes += scopes
+
+    subscriptions[type] = {
+      url: url,
+      compatibility: compatibility,
+      scopes: scopes,
+    }
+    File.write(EXAMPLES_DIR.join("#{type}.json"), JSON.pretty_generate(response))
+  end
+
+  File.write(BASE_DIR.join('meta.json'), JSON.pretty_generate({
+                                                                types: types.uniq,
+                                                                on_event_api: on_event_api.uniq,
+                                                                on_rtm: on_rtm.uniq,
+                                                                scopes: all_scopes.uniq,
+                                                                subscriptions: subscriptions,
+                                                              }))
+end
+
+write_response_sample

data/lib/slack_resources/generator/event_api/strong_hash.rb

@@ -0,0 +1,25 @@
+module SlackResources
+  module Generator
+    module StrongHash
+      refine Hash do
+        def protect_merge!(b)
+          b.keys.map do |new_key|
+            if self[new_key]
+              self[new_key] = b[new_key] if b[new_key].is_a?(Hash) && b[new_key]['type'].is_a?(Array)
+            else
+              self[new_key] = b[new_key]
+            end
+          end
+
+          self
+        end
+
+        def key_ordered
+          keys.sort.inject({}) do |a, k|
+            a.merge!(k => self[k])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack_resources/generator/event_api/to_schema.rb

@@ -0,0 +1,200 @@
+require 'json'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/keys'
+
+module SlackResources
+  module Generator
+    class ToSchema
+      using StrongHash
+
+      def initialize(example:, url:, preset:, key: 'root', defined: {}, defined_used: Set.new, parent: {}, root: nil)
+        @example = JSON.parse(example.to_json).key_ordered
+        @url = url
+        @preset = preset
+        @key = key
+        @defined = defined
+        @defined_used = defined_used
+        @parent = parent
+        @root = root || @example
+      end
+
+      def execute!
+        properties = @example.inject({}) do |a, (prop_name, value)|
+          type = TypeDetection.new(
+            parent_key: @key,
+            to_schema_instance: self,
+            prop_name: prop_name,
+            value: value,
+            container: @example,
+            preset: @preset
+          ).execute!
+
+          @defined_used << type if type.is_a?(String)
+
+          definition =
+            case
+            when TypeDetection.default_type?(type)
+              { 'type' => type }
+            when detail?(type)
+              type
+            when array_type?(type)
+              define_as_array(type, value)
+            else
+              ref_to(type)
+            end
+
+          a.merge(prop_name => definition)
+        end
+
+        [
+          {
+            'type' => 'object',
+            'description' => properties.blank? ? "definition snipped. learn more: #{@url}" : '(defined by script)',
+            'properties' => properties,
+          },
+          @defined,
+          @defined_used,
+        ]
+      end
+
+      def root_schema?
+        @root == @example
+      end
+
+      def root_type
+        @root['type']
+      end
+
+      def root_type_prefix
+        @root_type_prefix ||= root_type.split('_').shift
+      end
+
+      def array_type?(type)
+        type.to_s[0..1] == '[]'
+      end
+
+      def detail?(type)
+        type.is_a?(Hash)
+      end
+
+      def define_as_array(array_type, values)
+        type = array_type[2..-1]
+
+        if TypeDetection.default_type?(type)
+          return {
+            'type' => 'array',
+            'items' => {
+              'type' => type,
+            },
+          }
+        end
+
+        if values.first.is_a?(Hash)
+          to_child_schema(
+            prop_name: type,
+            example: values.first,
+            key: type,
+            parent: @example
+          )
+        elsif values.first.is_a?(String)
+          define_string(type)
+        end
+
+        {
+          'type' => 'array',
+          'items' => ref_to(type),
+        }
+      end
+
+      def define_object(k, v, types)
+        ref_key = k == 'item' ? "#{root_type_prefix}_item" : k
+
+        to_child_schema(
+          prop_name: ref_key,
+          example: v,
+          key: k,
+          parent: types
+        )
+
+        ref_key
+      end
+
+      def define_special_type(prop_name, value, container, const)
+        @defined_used << prop_name
+
+        return prop_name if @parent[prop_name]
+
+        types = value['items'].map { |v| detect_default_type(prop_name, v, container) }.uniq
+
+        @defined[prop_name] =
+          if const
+            { 'type' => normalize_type(types), enum: value['items'].uniq }
+          else
+            { 'type' => normalize_type(types) }
+          end
+
+        prop_name
+      end
+
+      def normalize_type(types)
+        types.size == 1 ? types[0] : types
+      end
+
+      def define_string(prop_name)
+        define_default_type(prop_name, 'string', nil)
+      end
+
+      def define_default_type(prop_name, value, container, const = false)
+        @defined.protect_merge!(
+          prop_name => {
+            'type' => detect_default_type(prop_name, value, container, const),
+          }
+        )
+        @defined_used << prop_name
+
+        ref_to(prop_name)
+      end
+
+      def detect_default_type(prop_name, value, container, const = false)
+        return define_special_type(prop_name, value, container, const) if value.is_a?(Hash) && value[TypeDetection::SPECIAL_TYPE] == TypeDetection::MULTIPLE_EXAMPLES
+
+        case value
+        when Integer
+          'number'
+        when Array
+          'array'
+        when Hash
+          define_object(prop_name, value, container)
+        when true, false
+          'boolean'
+        when nil
+          'null'
+        else
+          'string'
+        end
+      end
+
+      def ref_to(type)
+        { '$ref' => "#/definitions/#{type}" }
+      end
+
+      def to_child_schema(params)
+        prop_name = params.delete(:prop_name)
+        SlackResources::Generator::ToSchema.new(
+          example: @example,
+          url: @url,
+          preset: @preset,
+          key: @key,
+          defined: @defined,
+          defined_used: @defined_used,
+          parent: @parent,
+          root: @root,
+          **params
+        ).execute!.tap do |schema,|
+          @defined_used << prop_name
+          @defined[prop_name] = schema
+        end
+      end
+    end
+  end
+end

data/lib/slack_resources/generator/event_api/type_detection.rb

@@ -0,0 +1,272 @@
+require 'active_support/core_ext/module/delegation'
+
+module SlackResources
+  module Generator
+    class TypeDetection
+      using StrongHash
+
+      SPECIAL_TYPE = '_type'.freeze
+      MULTIPLE_EXAMPLES = 'MULTIPLE_EXAMPLES'.freeze
+
+      CONST_TYPES = %w[
+        type
+        subtype
+      ].freeze
+
+      DEFAULT_TYPES = Set.new(%w[
+        string
+        number
+        object
+        array
+        boolean
+        null
+      ])
+
+      STRING_ID_PROPERTIES_MAP = {
+        item_user: 'user_id',
+        user: 'user_id',
+        creator: 'user_id',
+        inviter: 'user_id',
+        created_by: 'user_id',
+        updated_by: 'user_id',
+        deleted_by: 'user_id',
+        channel: 'channel_id',
+        comment: 'comment_id',
+        team: 'team_id',
+      }.stringify_keys!
+
+      STRING_ID_PROPERTIES = Set.new(STRING_ID_PROPERTIES_MAP.keys)
+
+      DIRECT_STRING_PROPERTIES = Set.new(%w[
+        email_domain
+        text
+        description
+        handle
+        url
+        domain
+        challenge
+      ])
+
+      USER_COUNT_PROPERTIES = Set.new(%w[
+        user_count
+        added_users_count
+        removed_users_count
+      ])
+
+      ARRAY_PROPERTIES_TYPE_MAP = {
+        authed_users: 'user_id',
+        users: 'user_id',
+        added_users: 'user_id',
+        removed_users: 'user_id',
+        authed_teams: 'team_id',
+        channels: 'channel_id',
+        groups: 'group_id',
+        scopes: 'scope',
+        links: 'link',
+        oauth: 'string',
+        bot: 'string',
+        resources: 'resource_item',
+      }.stringify_keys!
+
+      TOKENS_REVOKED_ARRAY_PROPERTIES = Set.new(%w[
+        oauth
+        bot
+      ])
+
+      ARRAY_PROPERTIES = Set.new(ARRAY_PROPERTIES_TYPE_MAP.keys - TOKENS_REVOKED_ARRAY_PROPERTIES.to_a)
+
+      BOOLEAN = Set.new([true, false])
+
+      AMBIENT_PROPERTIES = Set.new(%w[
+        id
+        type
+        name
+        subtype
+        value
+        item
+      ])
+
+      class << self
+        def default_type?(type)
+          DEFAULT_TYPES.include?(type)
+        end
+      end
+
+      def initialize(to_schema_instance:, parent_key:, prop_name:, value:, container:, preset:)
+        @to_schema = to_schema_instance
+        @parent_key = parent_key
+        @prop_name = prop_name
+        @value = value
+        @container = container
+        @preset = preset
+      end
+
+      def execute! # rubocop:disable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
+        case
+        when root_schema? && constantable?
+          { 'const' => @value }
+        when item_schema? && type?
+          define_string("#{root_type_prefix}_#{@parent_key}_type")
+
+        when string_id?
+          define_string_id
+
+        when emoji_list?
+          define_string('emoji_name')
+          '[]emoji_name'
+        when emoji_alternative?
+          define_string('emoji_name')
+
+        when array?
+          define_array_type
+
+        when user_count?
+          'user_count'
+        when time_integer?
+          'time_integer'
+        when boolean?
+          'boolean'
+        when direct_string? || (on_url_verification? && @prop_name == 'token')
+          'string'
+        when timestamp?
+          'timestamp'
+
+        else
+          define_default_type(normalized_prop_name, @value, @container, const_type?)
+        end
+      end
+
+      private
+
+      delegate(
+        :root_schema?,
+        :define_string,
+        :root_type,
+        :root_type_prefix,
+        :define_default_type,
+        :define_object,
+        :define_enum,
+        :ref_to,
+        to: :@to_schema
+      )
+
+      def normalized_prop_name
+        if ambient?
+          root_schema? ? "#{root_type_prefix}_#{@prop_name}" : "#{@parent_key}_#{@prop_name}"
+        else
+          @prop_name
+        end
+      end
+
+      def type?
+        @prop_name == 'type'
+      end
+
+      def const_type?
+        CONST_TYPES.include?(@prop_name) || @prop_name.match(/_type$/)
+      end
+
+      def string?
+        @value.is_a?(String)
+      end
+
+      def constantable?
+        const_type? && (@value.is_a?(String) || @value.is_a?(Integer))
+      end
+
+      def emoji_alternative?
+        @prop_name == 'reaction'
+      end
+
+      def item_schema?
+        @parent_key == 'item'
+      end
+
+      def ambient?
+        AMBIENT_PROPERTIES.include?(@prop_name)
+      end
+
+      def time_integer?
+        @value.is_a?(Integer)
+      end
+
+      def boolean?
+        BOOLEAN.include?(@value)
+      end
+
+      def timestamp?
+        @prop_name == 'latest' || @prop_name.match(/.+_ts$/) || float_string?
+      end
+
+      def float_string?
+        @value.respond_to?(:to_f) && @value == @value.to_f.to_s
+      end
+
+      def array?
+        ARRAY_PROPERTIES.include?(@prop_name) || tokens_revoked_array?
+      end
+
+      def tokens_revoked_array?
+        on_tokens_revoked? && TOKENS_REVOKED_ARRAY_PROPERTIES.include?(@prop_name)
+      end
+
+      def user_count?
+        USER_COUNT_PROPERTIES.include?(@prop_name)
+      end
+
+      def direct_string?
+        DIRECT_STRING_PROPERTIES.include?(@prop_name)
+      end
+
+      def string_id?
+        @prop_name.match(/_id$/) || (string_value? && STRING_ID_PROPERTIES.include?(@prop_name))
+      end
+
+      def string_value?
+        @value.nil? || @value.is_a?(String)
+      end
+
+      def default_type?(type)
+        DEFAULT_TYPES.include?(type)
+      end
+
+      def emoji_list?
+        on_emoji_changed? && @prop_name == 'names'
+      end
+
+      def on_tokens_revoked?
+        root_type == 'tokens_revoked'
+      end
+
+      def on_url_verification?
+        root_type == 'url_verification'
+      end
+
+      def on_emoji_changed?
+        root_type == 'emoji_changed'
+      end
+
+      def define_array_type
+        type = ARRAY_PROPERTIES_TYPE_MAP[@prop_name]
+        array_type = "[]#{type}"
+
+        return array_type if default_type?(type)
+        return define_string(type) && array_type unless @value.is_a?(Hash)
+
+        to_child_schema(
+          prop_name: type,
+          example: @value.first,
+          key: @prop_name,
+          parent: @container
+        )
+
+        array_type
+      end
+
+      def define_string_id
+        type = STRING_ID_PROPERTIES_MAP[@prop_name] || @prop_name
+        define_string(type)
+      end
+    end
+  end
+end