captive-stack-detector 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '086052c42d95d9caf63c44c467e86e28c24c940c260d7752616ce8da6cea846f'
+  data.tar.gz: ab4f55fb35c1476f42e166a8df0f0f68ae7f13ea8b920061bd603c6f0cbb3d24
+SHA512:
+  metadata.gz: 001df9a9e62af902bc8bbd8816991a5c9af415d0a815912217c4ef0fe8dda479f4228cde5be4fa8a715eaf22fd109e335f73db182597fc0d8b737c9b53f866e9
+  data.tar.gz: c986ed711a7475e9c9f585e050f3d9deb7acc46e5f86dba6ffdcfa0ba7d03f0af5c7057c1e4d7ec937083f6f4276e62d8a2d8b66bbef70dacb6af03ef0c4c51b

data/lib/captive/stack/detector.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "../../captive_stack_detector"

data/lib/captive_stack_detector/env_vars_scanner.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CaptiveStackDetector
+  module EnvVarsScanner
+    HANDLED_VARS = %w[
+      RAILS_ENV SECRET_KEY_BASE DATABASE_URL REDIS_URL
+      RAILS_LOG_TO_STDOUT RAILS_SERVE_STATIC_FILES PORT RACK_ENV
+    ].freeze
+
+    ENV_KEY_PATTERN      = /ENV\.fetch\(['"]([A-Z_][A-Z0-9_]*)['"]|ENV\[['"]([A-Z_][A-Z0-9_]*)['"]\]/
+    SAFE_DEFAULT_PATTERN = /\A,\s*(?:nil\b|true\b|false\b|'[^']*'|"[^"]*"|\d+)\s*[,)]/
+    BLOCK_DEFAULT_PATTERN = /\A\s*\)\s*(?:do|\{)/
+    ASSIGNMENT_PATTERN   = /\A\s*\|\|=/
+
+    def self.scan(content)
+      result = {}
+      uncommented(content).scan(ENV_KEY_PATTERN) do |fetch_key, bracket_key|
+        after = Regexp.last_match.post_match
+        if bracket_key
+          next if ASSIGNMENT_PATTERN.match?(after)
+
+          result[bracket_key] ||= "placeholder"
+        else
+          next if SAFE_DEFAULT_PATTERN.match?(after) || BLOCK_DEFAULT_PATTERN.match?(after)
+
+          result[fetch_key] ||= "placeholder"
+        end
+      end
+      result.reject { |k, _| HANDLED_VARS.include?(k) }
+    end
+
+    def self.uncommented(content)
+      content.lines.reject { |l| l.match?(/^\s*#/) }.join
+    end
+    private_class_method :uncommented
+  end
+end

data/lib/captive_stack_detector/file_content_parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "env_vars_scanner"
+require_relative "node_version_detector"
+require_relative "ruby_version_detector"
+
+module CaptiveStackDetector
+  class FileContentParser
+    def initialize(reader)
+      @reader = reader
+    end
+
+    def ruby_version
+      RubyVersionDetector.new(@reader).detect
+    end
+
+    def node_version
+      NodeVersionDetector.new(@reader).detect
+    end
+
+    def env_vars
+      content = @reader.read("config/storage.yml")
+      content ? EnvVarsScanner.scan(content) : {}
+    end
+  end
+end

data/lib/captive_stack_detector/file_reader.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require_relative "file_content_parser"
+require_relative "github_api_client"
+
+module CaptiveStackDetector
+  class FileReader
+    def self.build(local_path: nil, github_token: nil, repo: nil)
+      return LocalFileReader.new(local_path) if local_path
+      return GithubFileReader.new(github_token, repo) if github_token && repo
+
+      raise ArgumentError, "local_path: ou github_token: + repo: requis"
+    end
+  end
+
+  class LocalFileReader
+    extend Forwardable
+
+    def_delegators :@parser, :ruby_version, :node_version, :env_vars
+
+    def initialize(path)
+      @path   = path
+      @parser = FileContentParser.new(self)
+    end
+
+    def read(filename)
+      full = File.join(@path, filename)
+      File.read(full, encoding: "utf-8") if File.exist?(full)
+    end
+  end
+
+  class GithubFileReader
+    extend Forwardable
+
+    def_delegators :@parser, :ruby_version, :node_version, :env_vars
+
+    def initialize(token, repo)
+      @client = GithubApiClient.new(token, repo)
+      @parser = FileContentParser.new(self)
+    end
+
+    def read(filename)
+      @client.fetch(filename)
+    end
+  end
+end

data/lib/captive_stack_detector/gemfile_analyzer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CaptiveStackDetector
+  class GemfileAnalyzer
+    ASSET_GEMS = %w[
+      sprockets sprockets-rails propshaft importmap-rails
+      cssbundling-rails jsbundling-rails dartsass-rails tailwindcss-rails
+    ].freeze
+
+    REDIS_GEMS = %w[redis redis-client sidekiq].freeze
+
+    def initialize(gemfile)
+      @gemfile = gemfile
+    end
+
+    def rails?   = gem?("rails")
+    def subtype  = ASSET_GEMS.any? { |g| gem?(g) } ? "app" : "api"
+    def database = gem?("pg") ? "postgres" : nil
+    def queue    = REDIS_GEMS.any? { |g| gem?(g) } ? "redis" : nil
+
+    def worker_command(procfile)
+      if procfile
+        procfile.each_line do |line|
+          m = line.match(/^worker:\s*(.+)$/)
+          return m[1].strip if m
+        end
+      end
+      gem?("sidekiq") ? "bundle exec sidekiq" : nil
+    end
+
+    private
+
+    def gem?(name)
+      @gemfile.match?(/gem ['"]#{Regexp.escape(name)}['"]/)
+    end
+  end
+end

data/lib/captive_stack_detector/github_api_client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "base64"
+require "json"
+
+module CaptiveStackDetector
+  class GithubApiClient
+    def initialize(token, repo)
+      @token = token
+      @repo  = repo
+    end
+
+    def fetch(filename)
+      uri = URI("https://api.github.com/repos/#{@repo}/contents/#{filename}")
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = "Bearer #{@token}"
+      req["Accept"]        = "application/vnd.github+json"
+
+      res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
+      return nil unless res.is_a?(Net::HTTPSuccess)
+
+      Base64.decode64(JSON.parse(res.body)["content"]).force_encoding("utf-8")
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/captive_stack_detector/js_stack_detector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../captive_stack_detector"
+require_relative "package_json_analyzer"
+
+module CaptiveStackDetector
+  class JsStackDetector
+    def initialize(reader, package_json)
+      @reader   = reader
+      @analyzer = PackageJsonAnalyzer.new(package_json)
+    end
+
+    def detect
+      type = @analyzer.type
+      raise UnsupportedStack unless type
+
+      Result.new(
+        type:     type,
+        subtype:  nil,
+        services: Services.new(database: @analyzer.database, queue: @analyzer.queue),
+        worker:   build_worker,
+        runtime:  Runtime.new(ruby: nil, node: @reader.node_version),
+        env_vars: {},
+      )
+    end
+
+    private
+
+    def build_worker
+      procfile = @reader.read("Procfile")
+      return nil unless procfile
+
+      procfile.each_line do |line|
+        m = line.match(/^worker:\s*(.+)$/)
+        return Worker.new(command: m[1].strip) if m
+      end
+      nil
+    end
+  end
+end

data/lib/captive_stack_detector/node_version_detector.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "json"
+
+module CaptiveStackDetector
+  class NodeVersionDetector
+    def initialize(reader)
+      @reader = reader
+    end
+
+    def detect
+      return from_nvmrc    if (nvmrc = @reader.read(".nvmrc"))
+      return from_tool_versions if (tv = @reader.read(".tool-versions"))
+      return from_package_json  if (pkg = @reader.read("package.json"))
+
+      nil
+    end
+
+    private
+
+    def from_nvmrc
+      @reader.read(".nvmrc").strip.sub(/^v/, "").split(".").first
+    end
+
+    def from_tool_versions
+      m = @reader.read(".tool-versions")&.match(/^nodejs\s+(\d+)/)
+      m&.[](1)
+    end
+
+    def from_package_json
+      m = JSON.parse(@reader.read("package.json")).dig("engines", "node")&.match(/\d+/)
+      m&.[](0)
+    end
+  end
+end

data/lib/captive_stack_detector/package_json_analyzer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "json"
+
+module CaptiveStackDetector
+  class PackageJsonAnalyzer
+    def initialize(package_json)
+      @parsed = JSON.parse(package_json)
+    end
+
+    def type
+      return "expo" if deps.key?("expo")
+      return "node" if @parsed.dig("scripts", "start")
+
+      nil
+    end
+
+    def database
+      deps.key?("pg") ? "postgres" : nil
+    end
+
+    def queue
+      (deps.key?("redis") || deps.key?("ioredis")) ? "redis" : nil
+    end
+
+    private
+
+    def deps
+      @parsed.fetch("dependencies", {}).merge(@parsed.fetch("devDependencies", {}))
+    end
+  end
+end

data/lib/captive_stack_detector/rails_stack_detector.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../captive_stack_detector"
+
+module CaptiveStackDetector
+  class RailsStackDetector
+    def initialize(reader, analyzer)
+      @reader   = reader
+      @analyzer = analyzer
+    end
+
+    def detect
+      raise UnsupportedStack unless @analyzer.rails?
+
+      Result.new(
+        type:     "rails",
+        subtype:  @analyzer.subtype,
+        services: Services.new(database: @analyzer.database, queue: @analyzer.queue),
+        worker:   build_worker,
+        runtime:  Runtime.new(ruby: @reader.ruby_version, node: nil),
+        env_vars: @reader.env_vars,
+      )
+    end
+
+    private
+
+    def build_worker
+      command = @analyzer.worker_command(@reader.read("Procfile"))
+      command ? Worker.new(command: command) : nil
+    end
+  end
+end

data/lib/captive_stack_detector/ruby_version_detector.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CaptiveStackDetector
+  class RubyVersionDetector
+    def initialize(reader)
+      @reader = reader
+    end
+
+    def detect
+      return from_tool_versions if @reader.read(".tool-versions")
+      return from_ruby_version   if @reader.read(".ruby-version")
+      return from_gemfile        if @reader.read("Gemfile")
+
+      nil
+    end
+
+    private
+
+    def from_tool_versions
+      @reader.read(".tool-versions")&.match(/^ruby\s+(\S+)/)&.[](1)
+    end
+
+    def from_ruby_version
+      @reader.read(".ruby-version")&.strip&.sub(/^ruby-/, "")
+    end
+
+    def from_gemfile
+      @reader.read("Gemfile")&.match(/^\s*ruby\s+['"](\d+\.\d+\.\d+)['"]/)&.[](1)
+    end
+  end
+end

data/lib/captive_stack_detector/types.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module CaptiveStackDetector
+  Services = Data.define(:database, :queue)
+  Worker   = Data.define(:command)
+  Runtime  = Data.define(:ruby, :node)
+  Result   = Data.define(:type, :subtype, :services, :worker, :runtime, :env_vars)
+
+  UnsupportedStack = Class.new(StandardError)
+end

data/lib/captive_stack_detector/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CaptiveStackDetector
+  VERSION = "0.1.1"
+end

data/lib/captive_stack_detector.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "captive_stack_detector/types"
+require_relative "captive_stack_detector/file_reader"
+require_relative "captive_stack_detector/gemfile_analyzer"
+require_relative "captive_stack_detector/rails_stack_detector"
+require_relative "captive_stack_detector/js_stack_detector"
+
+module CaptiveStackDetector
+  def self.detect(local_path: nil, github_token: nil, repo: nil)
+    reader = FileReader.build(local_path: local_path, github_token: github_token, repo: repo)
+    detect_from(reader)
+  end
+
+  def self.detect_from(reader)
+    gemfile      = reader.read("Gemfile")
+    package_json = reader.read("package.json")
+
+    return RailsStackDetector.new(reader, GemfileAnalyzer.new(gemfile)).detect if gemfile
+    return JsStackDetector.new(reader, package_json).detect                    if package_json
+
+    raise UnsupportedStack
+  end
+  private_class_method :detect_from
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: captive-stack-detector
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Captive Studio
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: 'Logique pure sans I/O : reçoit des strings de contenu de fichiers, retourne
+  un StackResult typé.'
+email:
+- dev@captive.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/captive/stack/detector.rb
+- lib/captive_stack_detector.rb
+- lib/captive_stack_detector/env_vars_scanner.rb
+- lib/captive_stack_detector/file_content_parser.rb
+- lib/captive_stack_detector/file_reader.rb
+- lib/captive_stack_detector/gemfile_analyzer.rb
+- lib/captive_stack_detector/github_api_client.rb
+- lib/captive_stack_detector/js_stack_detector.rb
+- lib/captive_stack_detector/node_version_detector.rb
+- lib/captive_stack_detector/package_json_analyzer.rb
+- lib/captive_stack_detector/rails_stack_detector.rb
+- lib/captive_stack_detector/ruby_version_detector.rb
+- lib/captive_stack_detector/types.rb
+- lib/captive_stack_detector/version.rb
+homepage: https://github.com/captive-studio/captive-stack-detector
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Détection de stack (Rails, Node, Expo) à partir du contenu de fichiers de
+  repo
+test_files: []