gettext_i18n_rails_js 2.2.0 → 2.2.1

data/vendor/bundle/ruby/3.4.0/gems/{json-2.13.2 → json-2.14.1}/lib/json/truffle_ruby/generator.rb

@@ -271,6 +271,12 @@ module JSON
             false
           end
 
+          if opts.key?(:allow_duplicate_key)
+            @allow_duplicate_key = !!opts[:allow_duplicate_key]
+          else
+            @allow_duplicate_key = nil # nil is deprecation
+          end
+
           @strict                = !!opts[:strict] if opts.key?(:strict)
 
           if !opts.key?(:max_nesting) # defaults to 100
@@ -284,6 +290,10 @@ module JSON
         end
         alias merge configure
 
+        def allow_duplicate_key? # :nodoc:
+          @allow_duplicate_key
+        end
+
         # Returns the configuration instance variables as a hash, that can be
         # passed to the configure method.
         def to_h
@@ -292,6 +302,11 @@ module JSON
             iv = iv.to_s[1..-1]
             result[iv.to_sym] = self[iv]
           end
+
+          if result[:allow_duplicate_key].nil?
+            result.delete(:allow_duplicate_key)
+          end
+
           result
         end
 
@@ -330,8 +345,17 @@ module JSON
           when Hash
             buf << '{'
             first = true
+            key_type = nil
             obj.each_pair do |k,v|
-              buf << ',' unless first
+              if first
+                key_type = k.class
+              else
+                if key_type && !@allow_duplicate_key && key_type != k.class
+                  key_type = nil # stop checking
+                  JSON.send(:on_mixed_keys_hash, obj, !@allow_duplicate_key.nil?)
+                end
+                buf << ','
+              end
 
               key_str = k.to_s
               if key_str.class == String
@@ -471,11 +495,30 @@ module JSON
             delim = ",#{state.object_nl}"
             result = +"{#{state.object_nl}"
             first = true
+            key_type = nil
             indent = !state.object_nl.empty?
             each { |key, value|
-              result << delim unless first
+              if first
+                key_type = key.class
+              else
+                if key_type && !state.allow_duplicate_key? && key_type != key.class
+                  key_type = nil # stop checking
+                  JSON.send(:on_mixed_keys_hash, self, state.allow_duplicate_key? == false)
+                end
+                result << delim
+              end
               result << state.indent * depth if indent
 
+              if state.strict? && !(Symbol === key || String === key)
+                if state.as_json
+                  key = state.as_json.call(key)
+                end
+
+                unless Symbol === key || String === key
+                  raise GeneratorError.new("#{key.class} not allowed as object key in JSON", value)
+                end
+              end
+
               key_str = key.to_s
               if key_str.is_a?(String)
                 key_json = key_str.to_json(state)
@@ -635,39 +678,6 @@ module JSON
           rescue Encoding::UndefinedConversionError => error
             raise ::JSON::GeneratorError.new(error.message, self)
           end
-
-          # Module that holds the extending methods if, the String module is
-          # included.
-          module Extend
-            # Raw Strings are JSON Objects (the raw bytes are stored in an
-            # array for the key "raw"). The Ruby String can be created by this
-            # module method.
-            def json_create(o)
-              o['raw'].pack('C*')
-            end
-          end
-
-          # Extends _modul_ with the String::Extend module.
-          def self.included(modul)
-            modul.extend Extend
-          end
-
-          # This method creates a raw object hash, that can be nested into
-          # other data structures and will be unparsed as a raw string. This
-          # method should be used, if you want to convert raw strings to JSON
-          # instead of UTF-8 strings, e. g. binary data.
-          def to_json_raw_object
-            {
-              JSON.create_id  => self.class.name,
-              'raw'           => self.unpack('C*'),
-            }
-          end
-
-          # This method creates a JSON text from the result of
-          # a call to to_json_raw_object of this String.
-          def to_json_raw(*args)
-            to_json_raw_object.to_json(*args)
-          end
         end
 
         module TrueClass

data/vendor/bundle/ruby/3.4.0/gems/{json-2.13.2 → json-2.14.1}/lib/json/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSON
-  VERSION = '2.13.2'
+  VERSION = '2.14.1'
 end

data/vendor/bundle/ruby/3.4.0/gems/{json-2.13.2 → json-2.14.1}/lib/json.rb

@@ -133,7 +133,7 @@ require 'json/common'
 # When not specified:
 #   # The last value is used and a deprecation warning emitted.
 #   JSON.parse('{"a": 1, "a":2}') => {"a" => 2}
-#   # waring: detected duplicate keys in JSON object.
+#   # warning: detected duplicate keys in JSON object.
 #   # This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`
 #
 # When set to `+true+`
@@ -307,6 +307,25 @@ require 'json/common'
 #
 # ---
 #
+# Option +allow_duplicate_key+ (boolean) specifies whether
+# hashes with duplicate keys should be allowed or produce an error.
+# defaults to emit a deprecation warning.
+#
+# With the default, (not set):
+#   Warning[:deprecated] = true
+#   JSON.generate({ foo: 1, "foo" => 2 })
+#   # warning: detected duplicate key "foo" in {foo: 1, "foo" => 2}.
+#   # This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true`
+#   # => '{"foo":1,"foo":2}'
+#
+# With <tt>false</tt>
+#   JSON.generate({ foo: 1, "foo" => 2 }, allow_duplicate_key: false)
+#   # detected duplicate key "foo" in {foo: 1, "foo" => 2} (JSON::GeneratorError)
+#
+# In version 3.0, <tt>false</tt> will become the default.
+#
+# ---
+#
 # Option +max_nesting+ (\Integer) specifies the maximum nesting depth
 # in +obj+; defaults to +100+.
 #
@@ -384,6 +403,9 @@ require 'json/common'
 #
 # == \JSON Additions
 #
+# Note that JSON Additions must only be used with trusted data, and is
+# deprecated.
+#
 # When you "round trip" a non-\String object from Ruby to \JSON and back,
 # you have a new \String, instead of the object you began with:
 #   ruby0 = Range.new(0, 2)

data/vendor/bundle/ruby/3.4.0/gems/marcel-1.1.0/README.md

@@ -0,0 +1,78 @@
+# Marcel
+
+Marcel chooses the most appropriate content type for a file by inspecting its contents, the declared MIME type (perhaps passed as a Content-Type header), and the file extension.
+
+Marcel checks, in order:
+
+1. The "magic bytes" sniffed from the file contents.
+2. The declared type, typically provided in a Content-Type header on an uploaded file, unless it's the `application/octet-stream` default.
+3. The filename extension.
+4. Safe fallback to the indeterminate `application/octet-stream` default.
+
+At each step, the most specific MIME subtype is selected. This allows the declared type and file extension to refine the parent type sniffed from the file contents, but not conflict with it. For example, if "file.csv" has declared type `text/plain`, `text/csv` is returned since it's a more specific subtype of `text/plain`. Similarly, Adobe Illustrator files are PDFs internally, so magic byte sniffing indicates `application/pdf` which is refined to `application/illustrator` by the `ai` file extension. But a PDF named "image.png" will still be detected as `application/pdf` since `image/png` is not a subtype.
+
+## Usage
+
+```ruby
+# Magic bytes sniffing alone
+Marcel::MimeType.for Pathname.new("example.gif")
+#  => "image/gif"
+
+File.open "example.gif" do |file|
+  Marcel::MimeType.for file
+end
+#  => "image/gif"
+
+# Magic bytes with filename fallback
+Marcel::MimeType.for Pathname.new("unrecognisable-data"), name: "example.pdf"
+#  => "application/pdf"
+
+# File extension alone
+Marcel::MimeType.for extension: ".pdf"
+#  => "application/pdf"
+
+# Magic bytes, declared type, and filename together
+Marcel::MimeType.for Pathname.new("unrecognisable-data"), name: "example", declared_type: "image/png"
+#  => "image/png"
+
+# Safe fallback to application/octet-stream
+Marcel::MimeType.for StringIO.new(File.read "unrecognisable-data")
+#  => "application/octet-stream"
+```
+
+## Extending
+
+Custom file types may be added with `Marcel::MimeType.extend`:
+
+```ruby
+Marcel::MimeType.extend "text/custom", extensions: %w( customtxt )
+Marcel::MimeType.for name: "file.customtxt"
+#  => "text/custom"
+```
+
+## Motivation
+
+Marcel was extracted from Basecamp's file detection heuristics. The aim is provide sensible, safe, "do what I expect" results for typical file handling. Test fixtures have been added for many common file types, including those typically encountered by Basecamp.
+
+
+## Contributing
+
+Marcel generates MIME lookup tables with `bundle exec rake update`. MIME types are seeded from data found in `data/*.xml`. Custom MIMEs may be added to `data/custom.xml`, while overrides to the standard MIME database may be added to `lib/marcel/mime_type/definitions.rb`.
+
+Marcel follows the same contributing guidelines as [rails/rails](https://github.com/rails/rails#contributing).
+
+
+## Testing
+
+The main test fixture files are split into two folders, those that can be recognised by magic bytes, and those that can only be recognised by name. Even though strictly unnecessary, the fixtures in both folders should all be valid files of the type they represent.
+
+
+## License
+
+Marcel itself is released under the terms of the MIT License. See the MIT-LICENSE file for details.
+
+Portions of Marcel are adapted from the [mimemagic] gem, released under the terms of the MIT License.
+
+Marcel's magic signature data is adapted from [Apache Tika](https://tika.apache.org), released under the terms of the Apache License. See the APACHE-LICENSE file for details.
+
+[mimemagic]: https://github.com/mimemagicrb/mimemagic

data/vendor/bundle/ruby/3.4.0/gems/{marcel-1.0.4 → marcel-1.1.0}/lib/marcel/magic.rb

@@ -119,7 +119,7 @@ module Marcel
 
       io.binmode if io.respond_to?(:binmode)
       io.set_encoding(Encoding::BINARY) if io.respond_to?(:set_encoding)
-      buffer = "".encode(Encoding::BINARY)
+      buffer = (+"").encode(Encoding::BINARY)
 
       MAGIC.send(method) { |type, matches| magic_match_io(io, matches, buffer) }
     end

data/vendor/bundle/ruby/3.4.0/gems/{marcel-1.0.4 → marcel-1.1.0}/lib/marcel/mime_type/definitions.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 Marcel::MimeType.extend "text/plain", extensions: %w( txt asc )
+Marcel::MimeType.extend "text/html", magic: [[0..64, "<!DOCTYPE HTML"], [0..64, "<!DOCTYPE html"], [0..64, "<!doctype HTML"], [0..64, "<!doctype html"]]
 
 Marcel::MimeType.extend "application/illustrator", parents: "application/pdf"
 Marcel::MimeType.extend "image/vnd.adobe.photoshop", magic: [[0, "8BPS"]], extensions: %w( psd psb )
@@ -43,6 +44,9 @@ Marcel::MimeType.extend "image/avif", magic: [[4, "ftypavif"]], extensions: %w(
 Marcel::MimeType.extend "image/heif", magic: [[4, "ftypmif1"]], extensions: %w( heif )
 Marcel::MimeType.extend "image/heic", magic: [[4, "ftypheic"]], extensions: %w( heic )
 
+Marcel::MimeType.extend "image/x-raw-sony", extensions: %w( arw ), parents: "image/tiff"
+Marcel::MimeType.extend "image/x-raw-canon",  extensions: %w( cr2 crw ), parents: "image/tiff"
+
 Marcel::MimeType.extend "video/mp4", magic: [[4, "ftypisom"], [4, "ftypM4V "]], extensions: %w( mp4 m4v )
 
 Marcel::MimeType.extend "audio/flac", magic: [[0, 'fLaC']], extensions: %w( flac ), parents: "audio/x-flac"