study_line 0.1.6 → 0.2.0

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/README.md

@@ -0,0 +1,266 @@
+# dotenv [![Gem Version](https://badge.fury.io/rb/dotenv.svg)](https://badge.fury.io/rb/dotenv) [![Join the chat at https://gitter.im/bkeepers/dotenv](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/bkeepers/dotenv?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Shim to load environment variables from `.env` into `ENV` in *development*.
+
+Storing [configuration in the environment](http://12factor.net/config) is one of the tenets of a [twelve-factor app](http://12factor.net). Anything that is likely to change between deployment environments–such as resource handles for databases or credentials for external services–should be extracted from the code into environment variables.
+
+But it is not always practical to set environment variables on development machines or continuous integration servers where multiple projects are run. dotenv loads variables from a `.env` file into `ENV` when the environment is bootstrapped.
+
+## Installation
+
+### Rails
+
+Add this line to the top of your application's Gemfile:
+
+```ruby
+gem 'dotenv-rails', groups: [:development, :test]
+```
+
+And then execute:
+
+```shell
+$ bundle
+```
+
+#### Note on load order
+
+dotenv is initialized in your Rails app during the `before_configuration` callback, which is fired when the `Application` constant is defined in `config/application.rb` with `class Application < Rails::Application`. If you need it to be initialized sooner, you can manually call `Dotenv::Railtie.load`.
+
+```ruby
+# config/application.rb
+Bundler.require(*Rails.groups)
+
+# Load dotenv only in development or test environment
+if ['development', 'test'].include? ENV['RAILS_ENV']
+  Dotenv::Railtie.load
+end
+
+HOSTNAME = ENV['HOSTNAME']
+```
+
+If you use gems that require environment variables to be set before they are loaded, then list `dotenv-rails` in the `Gemfile` before those other gems and require `dotenv/rails-now`.
+
+```ruby
+gem 'dotenv-rails', require: 'dotenv/rails-now'
+gem 'gem-that-requires-env-variables'
+```
+
+### Sinatra or Plain ol' Ruby
+
+Install the gem:
+
+```shell
+$ gem install dotenv
+```
+
+As early as possible in your application bootstrap process, load `.env`:
+
+```ruby
+require 'dotenv/load'
+
+# or
+require 'dotenv'
+Dotenv.load
+```
+
+By default, `load` will look for a file called `.env` in the current working directory. Pass in multiple files and they will be loaded in order. The first value set for a variable will win.
+
+```ruby
+require 'dotenv'
+Dotenv.load('file1.env', 'file2.env')
+```
+
+Alternatively, you can use the `dotenv` executable to launch your application:
+
+```shell
+$ dotenv ./script.rb
+```
+
+The `dotenv` executable also accepts a single flag, `-f`. Its value should be a comma-separated list of configuration files, in the order of most important to least. All of the files must exist. There _must_ be a space between the flag and its value.
+
+```
+$ dotenv -f ".env.local,.env" ./script.rb
+```
+
+To ensure `.env` is loaded in rake, load the tasks:
+
+```ruby
+require 'dotenv/tasks'
+
+task mytask: :dotenv do
+    # things that require .env
+end
+```
+
+## Usage
+
+Add your application configuration to your `.env` file in the root of your project:
+
+```shell
+S3_BUCKET=YOURS3BUCKET
+SECRET_KEY=YOURSECRETKEYGOESHERE
+```
+
+Whenever your application loads, these variables will be available in `ENV`:
+
+```ruby
+config.fog_directory  = ENV['S3_BUCKET']
+```
+
+You may also add `export` in front of each line so you can `source` the file in bash:
+
+```shell
+export S3_BUCKET=YOURS3BUCKET
+export SECRET_KEY=YOURSECRETKEYGOESHERE
+```
+
+### Multi-line values
+
+If you need multiline variables, for example private keys, you can double quote strings and use the `\n` character for newlines:
+
+```shell
+PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----\nHkVN9...\n-----END DSA PRIVATE KEY-----\n"
+```
+
+Alternatively, multi-line values with line breaks are now supported for quoted values.
+
+```shell
+PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----
+...
+HkVN9...
+...
+-----END DSA PRIVATE KEY-----"
+```
+
+This is particularly helpful when using the Heroku command line plugin [`heroku-config`](https://github.com/xavdid/heroku-config) to pull configuration variables down that may have line breaks.
+
+### Command Substitution
+
+You need to add the output of a command in one of your variables? Simply add it with `$(your_command)`:
+
+```shell
+DATABASE_URL="postgres://$(whoami)@localhost/my_database"
+```
+
+### Variable Substitution
+
+You need to add the value of another variable in one of your variables? You can reference the variable with `${VAR}` or often just `$VAR` in unqoted or double-quoted values.
+
+```shell
+DATABASE_URL="postgres://${USER}@localhost/my_database"
+```
+
+If a value contains a `$` and it is not intended to be a variable, wrap it in single quotes.
+
+```shell
+PASSWORD='pas$word'
+```
+
+### Comments
+
+Comments may be added to your file as such:
+
+```shell
+# This is a comment
+SECRET_KEY=YOURSECRETKEYGOESHERE # comment
+SECRET_HASH="something-with-a-#-hash"
+```
+
+### Required Keys
+
+If a particular configuration value is required but not set, it's appropriate to raise an error.
+
+To require configuration keys:
+
+```ruby
+# config/initializers/dotenv.rb
+
+Dotenv.require_keys("SERVICE_APP_ID", "SERVICE_KEY", "SERVICE_SECRET")
+```
+
+If any of the configuration keys above are not set, your application will raise an error during initialization. This method is preferred because it prevents runtime errors in a production application due to improper configuration.
+
+### Parsing
+
+To parse a list of env files for programmatic inspection without modifying the ENV:
+
+```ruby
+Dotenv.parse(".env.local", ".env")
+# => {'S3_BUCKET' => 'YOURS3BUCKET', 'SECRET_KEY' => 'YOURSECRETKEYGOESHERE', ...}
+```
+
+This method returns a hash of the ENV var name/value pairs.
+
+## Frequently Answered Questions
+
+### Can I use dotenv in production?
+
+dotenv was originally created to load configuration variables into `ENV` in *development*. There are typically better ways to manage configuration in production environments - such as `/etc/environment` managed by [Puppet](https://github.com/puppetlabs/puppet) or [Chef](https://github.com/chef/chef), `heroku config`, etc.
+
+However, some find dotenv to be a convenient way to configure Rails applications in staging and production environments, and you can do that by defining environment-specific files like `.env.production` or `.env.test`.
+
+If you use this gem to handle env vars for multiple Rails environments (development, test, production, etc.), please note that env vars that are general to all environments should be stored in `.env`. Then, environment specific env vars should be stored in `.env.<that environment's name>`.
+
+### What other .env* files can I use?
+
+`dotenv-rails` will override in the following order (highest defined variable overrides lower):
+
+| Hierarchy Priority | Filename                 | Environment          | Should I `.gitignore`it?                            | Notes                                                        |
+| ------------------ | ------------------------ | -------------------- | --------------------------------------------------- | ------------------------------------------------------------ |
+| 1st (highest)      | `.env.development.local` | Development          | Yes!                                                | Local overrides of environment-specific settings.            |
+| 1st                | `.env.test.local`        | Test                 | Yes!                                                | Local overrides of environment-specific settings.            |
+| 1st                | `.env.production.local`  | Production           | Yes!                                                | Local overrides of environment-specific settings.            |
+| 2nd                | `.env.local`             | Wherever the file is | Definitely.                                         | Local overrides. This file is loaded for all environments _except_ `test`. |
+| 3rd                | `.env.development`       | Development          | No.                                                 | Shared environment-specific settings                         |
+| 3rd                | `.env.test`              | Test                 | No.                                                 | Shared environment-specific settings                         |
+| 3rd                | `.env.production`        | Production           | No.                                                 | Shared environment-specific settings                         |
+| Last               | `.env`                   | All Environments     | Depends (See [below](#should-i-commit-my-env-file)) | The Original®                                                |
+
+
+### Should I commit my .env file?
+
+Credentials should only be accessible on the machines that need access to them. Never commit sensitive information to a repository that is not needed by every development machine and server.
+
+
+You can use the `-t` or `--template` flag on the dotenv cli to create a template of your `.env` file.
+```shell
+$ dotenv -t .env
+```
+A template will be created in your working directory named `{FINAME}.template`. So in the above example, it would create a `.env.template` file.
+
+The template will contain all the environment variables in your `.env` file but with their values set to the variable names.
+
+```shell
+# .env
+S3_BUCKET=YOURS3BUCKET
+SECRET_KEY=YOURSECRETKEYGOESHERE
+```
+
+Would become
+
+```shell
+# .env.template
+S3_BUCKET=S3_BUCKET
+SECRET_KEY=SECRET_KEY
+```
+
+Personally, I prefer to commit the `.env` file with development-only settings. This makes it easy for other developers to get started on the project without compromising credentials for other environments. If you follow this advice, make sure that all the credentials for your development environment are different from your other deployments and that the development credentials do not have access to any confidential data.
+
+### Why is it not overriding existing `ENV` variables?
+
+By default, it **won't** overwrite existing environment variables as dotenv assumes the deployment environment has more knowledge about configuration than the application does. To overwrite existing environment variables you can use `Dotenv.overload`.
+
+You can also use the `-o` or `--overload` flag on the dotenv cli to override existing `ENV` variables.
+```shell
+$ dotenv -o -f ".env.local,.env"
+```
+
+## Contributing
+
+If you want a better idea of how dotenv works, check out the [Ruby Rogues Code Reading of dotenv](https://www.youtube.com/watch?v=lKmY_0uY86s).
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/bin/dotenv

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "dotenv/cli"
+Dotenv::CLI.new(ARGV).run

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/lib/dotenv/cli.rb

@@ -0,0 +1,57 @@
+require "dotenv"
+require "dotenv/version"
+require "dotenv/template"
+require "optparse"
+
+module Dotenv
+  # The command line interface
+  class CLI < OptionParser
+    attr_reader :argv, :filenames, :overload
+
+    def initialize(argv = [])
+      @argv = argv.dup
+      @filenames = []
+      @overload = false
+
+      super "Usage: dotenv [options]"
+      separator ""
+
+      on("-f FILES", Array, "List of env files to parse") do |list|
+        @filenames = list
+      end
+
+      on("-o", "--overload", "override existing ENV variables") do
+        @overload = true
+      end
+
+      on("-h", "--help", "Display help") do
+        puts self
+        exit
+      end
+
+      on("-v", "--version", "Show version") do
+        puts "dotenv #{Dotenv::VERSION}"
+        exit
+      end
+
+      on("-t", "--template=FILE", "Create a template env file") do |file|
+        template = Dotenv::EnvTemplate.new(file)
+        template.create_template
+      end
+
+      order!(@argv)
+    end
+
+    def run
+      if @overload
+        Dotenv.overload!(*@filenames)
+      else
+        Dotenv.load!(*@filenames)
+      end
+    rescue Errno::ENOENT => e
+      abort e.message
+    else
+      exec(*@argv) unless @argv.empty?
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/lib/dotenv/environment.rb

@@ -0,0 +1,28 @@
+module Dotenv
+  # This class inherits from Hash and represents the environment into which
+  # Dotenv will load key value pairs from a file.
+  class Environment < Hash
+    attr_reader :filename
+
+    def initialize(filename, is_load = false)
+      @filename = filename
+      load(is_load)
+    end
+
+    def load(is_load = false)
+      update Parser.call(read, is_load)
+    end
+
+    def read
+      File.open(@filename, "rb:bom|utf-8", &:read)
+    end
+
+    def apply
+      each { |k, v| ENV[k] ||= v }
+    end
+
+    def apply!
+      each { |k, v| ENV[k] = v }
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/lib/dotenv/load.rb

@@ -0,0 +1,2 @@
+require "dotenv"
+Dotenv.load

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/lib/dotenv/missing_keys.rb

@@ -0,0 +1,10 @@
+module Dotenv
+  class Error < StandardError; end
+
+  class MissingKeys < Error # :nodoc:
+    def initialize(keys)
+      key_word = "key#{keys.size > 1 ? "s" : ""}"
+      super("Missing required configuration #{key_word}: #{keys.inspect}")
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/lib/dotenv/parser.rb

@@ -0,0 +1,109 @@
+require "dotenv/substitutions/variable"
+require "dotenv/substitutions/command" if RUBY_VERSION > "1.8.7"
+
+module Dotenv
+  class FormatError < SyntaxError; end
+
+  # This class enables parsing of a string for key value pairs to be returned
+  # and stored in the Environment. It allows for variable substitutions and
+  # exporting of variables.
+  class Parser
+    @substitutions =
+      [Dotenv::Substitutions::Variable, Dotenv::Substitutions::Command]
+
+    LINE = /
+      (?:^|\A)              # beginning of line
+      \s*                   # leading whitespace
+      (?:export\s+)?        # optional export
+      ([\w.]+)              # key
+      (?:\s*=\s*?|:\s+?)    # separator
+      (                     # optional value begin
+        \s*'(?:\\'|[^'])*'  #   single quoted value
+        |                   #   or
+        \s*"(?:\\"|[^"])*"  #   double quoted value
+        |                   #   or
+        [^\#\r\n]+          #   unquoted value
+      )?                    # value end
+      \s*                   # trailing whitespace
+      (?:\#.*)?             # optional comment
+      (?:$|\z)              # end of line
+    /x
+
+    class << self
+      attr_reader :substitutions
+
+      def call(string, is_load = false)
+        new(string, is_load).call
+      end
+    end
+
+    def initialize(string, is_load = false)
+      @string = string
+      @hash = {}
+      @is_load = is_load
+    end
+
+    def call
+      # Convert line breaks to same format
+      lines = @string.gsub(/\r\n?/, "\n")
+      # Process matches
+      lines.scan(LINE).each do |key, value|
+        @hash[key] = parse_value(value || "")
+      end
+      # Process non-matches
+      lines.gsub(LINE, "").split(/[\n\r]+/).each do |line|
+        parse_line(line)
+      end
+      @hash
+    end
+
+    private
+
+    def parse_line(line)
+      if line.split.first == "export"
+        if variable_not_set?(line)
+          raise FormatError, "Line #{line.inspect} has an unset variable"
+        end
+      end
+    end
+
+    def parse_value(value)
+      # Remove surrounding quotes
+      value = value.strip.sub(/\A(['"])(.*)\1\z/m, '\2')
+      maybe_quote = Regexp.last_match(1)
+      value = unescape_value(value, maybe_quote)
+      perform_substitutions(value, maybe_quote)
+    end
+
+    def unescape_characters(value)
+      value.gsub(/\\([^$])/, '\1')
+    end
+
+    def expand_newlines(value)
+      value.gsub('\n', "\n").gsub('\r', "\r")
+    end
+
+    def variable_not_set?(line)
+      !line.split[1..-1].all? { |var| @hash.member?(var) }
+    end
+
+    def unescape_value(value, maybe_quote)
+      if maybe_quote == '"'
+        unescape_characters(expand_newlines(value))
+      elsif maybe_quote.nil?
+        unescape_characters(value)
+      else
+        value
+      end
+    end
+
+    def perform_substitutions(value, maybe_quote)
+      if maybe_quote != "'"
+        self.class.substitutions.each do |proc|
+          value = proc.call(value, @hash, @is_load)
+        end
+      end
+      value
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/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, _is_load)
+          # 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..-1]
+            else
+              # Execute the command and return the value
+              `#{command}`.chomp
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/lib/dotenv/substitutions/variable.rb

@@ -0,0 +1,43 @@
+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 $
+          (?!\()        # shouldnt be followed by paranthesis
+          \{?           # allow brace wrapping
+          ([A-Z0-9_]+)? # optional alpha nums
+          \}?           # closing brace
+        /xi
+
+        def call(value, env, is_load)
+          combined_env = is_load ? env.merge(ENV) : ENV.to_h.merge(env)
+          value.gsub(VARIABLE) do |variable|
+            match = $LAST_MATCH_INFO
+            substitute(match, variable, combined_env)
+          end
+        end
+
+        private
+
+        def substitute(match, variable, env)
+          if match[1] == "\\"
+            variable[1..-1]
+          elsif match[3]
+            env.fetch(match[3], "")
+          else
+            variable
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/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/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/lib/dotenv/template.rb

@@ -0,0 +1,26 @@
+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|
+            env_template.puts template_line(line)
+          end
+        end
+      end
+    end
+
+    def template_line(line)
+      var, value = line.split("=")
+      template = var.gsub(EXPORT_COMMAND, "")
+      is_a_comment = var.strip[0].eql?("#")
+      value.nil? || is_a_comment ? line : "#{var}=#{template}"
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/lib/dotenv/version.rb

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

data/vendor/bundle/ruby/3.2.0/gems/dotenv-2.8.1/lib/dotenv.rb

@@ -0,0 +1,86 @@
+require "dotenv/parser"
+require "dotenv/environment"
+require "dotenv/missing_keys"
+
+# The top level Dotenv module. The entrypoint for the application logic.
+module Dotenv
+  class << self
+    attr_accessor :instrumenter
+  end
+
+  module_function
+
+  def load(*filenames)
+    with(*filenames) do |f|
+      ignoring_nonexistent_files do
+        env = Environment.new(f, true)
+        instrument("dotenv.load", env: env) { env.apply }
+      end
+    end
+  end
+
+  # same as `load`, but raises Errno::ENOENT if any files don't exist
+  def load!(*filenames)
+    with(*filenames) do |f|
+      env = Environment.new(f, true)
+      instrument("dotenv.load", env: env) { env.apply }
+    end
+  end
+
+  # same as `load`, but will override existing values in `ENV`
+  def overload(*filenames)
+    with(*filenames) do |f|
+      ignoring_nonexistent_files do
+        env = Environment.new(f, false)
+        instrument("dotenv.overload", env: env) { env.apply! }
+      end
+    end
+  end
+
+  # same as `overload`, but raises Errno::ENOENT if any files don't exist
+  def overload!(*filenames)
+    with(*filenames) do |f|
+      env = Environment.new(f, false)
+      instrument("dotenv.overload", env: env) { env.apply! }
+    end
+  end
+
+  # returns a hash of parsed key/value pairs but does not modify ENV
+  def parse(*filenames)
+    with(*filenames) do |f|
+      ignoring_nonexistent_files do
+        Environment.new(f, false)
+      end
+    end
+  end
+
+  # Internal: Helper to expand list of filenames.
+  #
+  # Returns a hash of all the loaded environment variables.
+  def with(*filenames)
+    filenames << ".env" if filenames.empty?
+
+    filenames.reduce({}) do |hash, filename|
+      hash.merge!(yield(File.expand_path(filename)) || {})
+    end
+  end
+
+  def instrument(name, payload = {}, &block)
+    if instrumenter
+      instrumenter.instrument(name, payload, &block)
+    else
+      yield
+    end
+  end
+
+  def require_keys(*keys)
+    missing_keys = keys.flatten - ::ENV.keys
+    return if missing_keys.empty?
+    raise MissingKeys, missing_keys
+  end
+
+  def ignoring_nonexistent_files
+    yield
+  rescue Errno::ENOENT
+  end
+end