tiny-sharp-pkg 0.0.1

data/dotenv-3.2.0/lib/dotenv/parser.rb

@@ -0,0 +1,109 @@
+require "dotenv/substitutions/variable"
+require "dotenv/substitutions/command" if RUBY_VERSION > "1.8.7"
+
+module Dotenv
+  # Error raised when encountering a syntax error while parsing a .env file.
+  class FormatError < SyntaxError; end
+
+  # Parses the `.env` file format into key/value pairs.
+  # It allows for variable substitutions, command substitutions, and exporting of variables.
+  class Parser
+    @substitutions = [
+      Dotenv::Substitutions::Command,
+      Dotenv::Substitutions::Variable
+    ]
+
+    LINE = /
+      (?:^|\A)                # beginning of line
+      \s*                     # leading whitespace
+      (?<export>export\s+)?   # optional export
+      (?<key>[\w.]+)          # key
+      (?:                     # optional separator and value
+        (?:\s*=\s*?|:\s+?)    #   separator
+        (?<value>             #   optional value begin
+          \s*'(?:\\'|[^'])*'  #     single quoted value
+          |                   #     or
+          \s*"(?:\\"|[^"])*"  #     double quoted value
+          |                   #     or
+          [^\#\n]+            #     unquoted value
+        )?                    #   value end
+      )?                      # separator and value end
+      \s*                     # trailing whitespace
+      (?:\#.*)?               # optional comment
+      (?:$|\z)                # end of line
+    /x
+
+    QUOTED_STRING = /\A(['"])(.*)\1\z/m
+
+    class << self
+      attr_reader :substitutions
+
+      def call(...)
+        new(...).call
+      end
+    end
+
+    def initialize(string, overwrite: false)
+      # Convert line breaks to same format
+      @string = string.gsub(/\r\n?/, "\n")
+      @hash = {}
+      @overwrite = overwrite
+    end
+
+    def call
+      @string.scan(LINE) do
+        match = $LAST_MATCH_INFO
+
+        if existing?(match[:key])
+          # Use value from already defined variable
+          @hash[match[:key]] = ENV[match[:key]]
+        elsif match[:export] && !match[:value]
+          # Check for exported variable with no value
+          if !@hash.member?(match[:key])
+            raise FormatError, "Line #{match.to_s.inspect} has an unset variable"
+          end
+        else
+          @hash[match[:key]] = parse_value(match[:value] || "")
+        end
+      end
+
+      @hash
+    end
+
+    private
+
+    # Determine if a variable is already defined and should not be overwritten.
+    def existing?(key)
+      !@overwrite && key != "DOTENV_LINEBREAK_MODE" && ENV.key?(key)
+    end
+
+    def parse_value(value)
+      # Remove surrounding quotes
+      value = value.strip.sub(QUOTED_STRING, '\2')
+      maybe_quote = Regexp.last_match(1)
+
+      # Expand new lines in double quoted values
+      value = expand_newlines(value) if maybe_quote == '"'
+
+      # Unescape characters and performs substitutions unless value is single quoted
+      if maybe_quote != "'"
+        value = unescape_characters(value)
+        self.class.substitutions.each { |proc| value = proc.call(value, @hash) }
+      end
+
+      value
+    end
+
+    def unescape_characters(value)
+      value.gsub(/\\([^$])/, '\1')
+    end
+
+    def expand_newlines(value)
+      if (@hash["DOTENV_LINEBREAK_MODE"] || ENV["DOTENV_LINEBREAK_MODE"]) == "legacy"
+        value.gsub('\n', "\n").gsub('\r', "\r")
+      else
+        value.gsub('\n', "\\\\\\n").gsub('\r', "\\\\\\r")
+      end
+    end
+  end
+end

data/dotenv-3.2.0/lib/dotenv/rails-now.rb

@@ -0,0 +1,10 @@
+# If you use gems that require environment variables to be set before they are
+# loaded, then list `dotenv` in the `Gemfile` before those other gems and
+# require `dotenv/load`.
+#
+#     gem "dotenv", require: "dotenv/load"
+#     gem "gem-that-requires-env-variables"
+#
+
+require "dotenv/load"
+warn '[DEPRECATION] `require "dotenv/rails-now"` is deprecated. Use `require "dotenv/load"` instead.', caller(1..1).first

data/dotenv-3.2.0/lib/dotenv/rails.rb

@@ -0,0 +1,111 @@
+# Since rubygems doesn't support optional dependencies, we have to manually check
+unless Gem::Requirement.new(">= 6.1").satisfied_by?(Gem::Version.new(Rails.version))
+  warn "dotenv 3.0 only supports Rails 6.1 or later. Use dotenv ~> 2.0."
+  return
+end
+
+require "dotenv/replay_logger"
+require "dotenv/log_subscriber"
+
+Dotenv.instrumenter = ActiveSupport::Notifications
+
+# Watch all loaded env files with Spring
+ActiveSupport::Notifications.subscribe("load.dotenv") do |*args|
+  if defined?(Spring) && Spring.respond_to?(:watch)
+    event = ActiveSupport::Notifications::Event.new(*args)
+    Spring.watch event.payload[:env].filename if Rails.application
+  end
+end
+
+module Dotenv
+  # Rails integration for using Dotenv to load ENV variables from a file
+  class Rails < ::Rails::Railtie
+    delegate :files, :files=, :overwrite, :overwrite=, :autorestore, :autorestore=, :logger, to: "config.dotenv"
+
+    def initialize
+      super
+      config.dotenv = ActiveSupport::OrderedOptions.new.update(
+        # Rails.logger is not available yet, so we'll save log messages and replay them when it is
+        logger: Dotenv::ReplayLogger.new,
+        overwrite: false,
+        files: [
+          ".env.#{env}.local",
+          (".env.local" unless env.test?),
+          ".env.#{env}",
+          ".env"
+        ].compact,
+        autorestore: env.test? && !defined?(ClimateControl) && !defined?(IceAge)
+      )
+    end
+
+    # Public: Load dotenv
+    #
+    # This will get called during the `before_configuration` callback, but you
+    # can manually call `Dotenv::Rails.load` if you needed it sooner.
+    def load
+      Dotenv.load(*files.map { |file| root.join(file).to_s }, overwrite: overwrite)
+    end
+
+    def overload
+      deprecator.warn("Dotenv::Rails.overload is deprecated. Set `Dotenv::Rails.overwrite = true` and call Dotenv::Rails.load instead.")
+      Dotenv.load(*files.map { |file| root.join(file).to_s }, overwrite: true)
+    end
+
+    # Internal: `Rails.root` is nil in Rails 4.1 before the application is
+    # initialized, so this falls back to the `RAILS_ROOT` environment variable,
+    # or the current working directory.
+    def root
+      ::Rails.root || Pathname.new(ENV["RAILS_ROOT"] || Dir.pwd)
+    end
+
+    # Set a new logger and replay logs
+    def logger=(new_logger)
+      logger.replay new_logger if logger.is_a?(ReplayLogger)
+      config.dotenv.logger = new_logger
+    end
+
+    # The current environment that the app is running in.
+    #
+    # When running `rake`, the Rails application is initialized in development, so we have to
+    # check which rake tasks are being run to determine the environment.
+    #
+    # See https://github.com/bkeepers/dotenv/issues/219
+    def env
+      @env ||= if defined?(Rake.application) && Rake.application.top_level_tasks.grep(TEST_RAKE_TASKS).any?
+        env = Rake.application.options.show_tasks ? "development" : "test"
+        ActiveSupport::EnvironmentInquirer.new(env)
+      else
+        ::Rails.env
+      end
+    end
+    TEST_RAKE_TASKS = /^(default$|test(:|$)|parallel:spec|spec(:|$))/
+
+    def deprecator # :nodoc:
+      @deprecator ||= ActiveSupport::Deprecation.new
+    end
+
+    # Rails uses `#method_missing` to delegate all class methods to the
+    # instance, which means `Kernel#load` gets called here. We don't want that.
+    def self.load
+      instance.load
+    end
+
+    initializer "dotenv", after: :initialize_logger do |app|
+      if logger.is_a?(ReplayLogger)
+        self.logger = ActiveSupport::TaggedLogging.new(::Rails.logger).tagged("dotenv")
+      end
+    end
+
+    initializer "dotenv.deprecator" do |app|
+      app.deprecators[:dotenv] = deprecator if app.respond_to?(:deprecators)
+    end
+
+    initializer "dotenv.autorestore" do |app|
+      require "dotenv/autorestore" if autorestore
+    end
+
+    config.before_configuration { load }
+  end
+
+  Railtie = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("Dotenv::Railtie", "Dotenv::Rails", Dotenv::Rails.deprecator)
+end

data/dotenv-3.2.0/lib/dotenv/replay_logger.rb

@@ -0,0 +1,20 @@
+module Dotenv
+  # A logger that can be used before the apps real logger is initialized.
+  class ReplayLogger < Logger
+    def initialize
+      super(nil) # Doesn't matter what this is, it won't be used.
+      @logs = []
+    end
+
+    # Override the add method to store logs so we can replay them to a real logger later.
+    def add(*args, &block)
+      @logs.push([args, block])
+    end
+
+    # Replay the store logs to a real logger.
+    def replay(logger)
+      @logs.each { |args, block| logger.add(*args, &block) }
+      @logs.clear
+    end
+  end
+end

data/dotenv-3.2.0/lib/dotenv/substitutions/command.rb

@@ -0,0 +1,41 @@
+require "English"
+
+module Dotenv
+  module Substitutions
+    # Substitute shell commands in a value.
+    #
+    #   SHA=$(git rev-parse HEAD)
+    #
+    module Command
+      class << self
+        INTERPOLATED_SHELL_COMMAND = /
+          (?<backslash>\\)?   # is it escaped with a backslash?
+          \$                  # literal $
+          (?<cmd>             # collect command content for eval
+            \(                # require opening paren
+            (?:[^()]|\g<cmd>)+  # allow any number of non-parens, or balanced
+                              # parens (by nesting the <cmd> expression
+                              # recursively)
+            \)                # require closing paren
+          )
+        /x
+
+        def call(value, env)
+          # Process interpolated shell commands
+          value.gsub(INTERPOLATED_SHELL_COMMAND) do |*|
+            # Eliminate opening and closing parentheses
+            command = $LAST_MATCH_INFO[:cmd][1..-2]
+
+            if $LAST_MATCH_INFO[:backslash]
+              # Command is escaped, don't replace it.
+              $LAST_MATCH_INFO[0][1..]
+            else
+              # Execute the command and return the value
+              `#{Variable.call(command, env)}`.chomp
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/dotenv-3.2.0/lib/dotenv/substitutions/variable.rb

@@ -0,0 +1,37 @@
+require "English"
+
+module Dotenv
+  module Substitutions
+    # Substitute variables in a value.
+    #
+    #   HOST=example.com
+    #   URL="https://$HOST"
+    #
+    module Variable
+      class << self
+        VARIABLE = /
+          (\\)?         # is it escaped with a backslash?
+          (\$)          # literal $
+          (?!\()        # shouldn't be followed by parenthesis
+          \{?           # allow brace wrapping
+          ([A-Z0-9_]+)? # optional alpha nums
+          \}?           # closing brace
+        /xi
+
+        def call(value, env)
+          value.gsub(VARIABLE) do |variable|
+            match = $LAST_MATCH_INFO
+
+            if match[1] == "\\"
+              variable[1..]
+            elsif match[3]
+              env[match[3]] || ENV[match[3]] || ""
+            else
+              variable
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/dotenv-3.2.0/lib/dotenv/tasks.rb

@@ -0,0 +1,7 @@
+desc "Load environment settings from .env"
+task :dotenv do
+  require "dotenv"
+  Dotenv.load
+end
+
+task environment: :dotenv

data/dotenv-3.2.0/lib/dotenv/template.rb

@@ -0,0 +1,44 @@
+module Dotenv
+  EXPORT_COMMAND = "export ".freeze
+  # Class for creating a template from a env file
+  class EnvTemplate
+    def initialize(env_file)
+      @env_file = env_file
+    end
+
+    def create_template
+      File.open(@env_file, "r") do |env_file|
+        File.open("#{@env_file}.template", "w") do |env_template|
+          env_file.each do |line|
+            if is_comment?(line)
+              env_template.puts line
+            elsif (var = var_defined?(line))
+              if line.match(EXPORT_COMMAND)
+                env_template.puts "export #{var}=#{var}"
+              else
+                env_template.puts "#{var}=#{var}"
+              end
+            elsif line_blank?(line)
+              env_template.puts
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def is_comment?(line)
+      line.strip.start_with?("#")
+    end
+
+    def var_defined?(line)
+      match = Dotenv::Parser::LINE.match(line)
+      match && match[:key]
+    end
+
+    def line_blank?(line)
+      line.strip.length.zero?
+    end
+  end
+end

data/dotenv-3.2.0/lib/dotenv/version.rb

@@ -0,0 +1,3 @@
+module Dotenv
+  VERSION = "3.2.0".freeze
+end