Add bin and edit workflow

bin/gems/safe_yaml-1.0.5/spec/resolver_specs.rb

@@ -0,0 +1,278 @@
+module ResolverSpecs
+  def self.included(base)
+    base.module_eval do
+      let(:resolver) { nil }
+      let(:result) { @result }
+
+      before :each do
+        # See the comment in the first before :each block in safe_yaml_spec.rb.
+        require "safe_yaml"
+      end
+
+      def parse(yaml)
+        tree = YAML.parse(yaml.unindent)
+        @result = resolver.resolve_node(tree)
+      end
+
+      # Isn't this how I should've been doing it all along?
+      def parse_and_test(yaml)
+        safe_result = parse(yaml)
+
+        exception_thrown = nil
+
+        unsafe_result = begin
+          YAML.unsafe_load(yaml)
+        rescue Exception => e
+          exception_thrown = e
+        end
+
+        if exception_thrown
+          # If the underlying YAML parser (e.g. Psych) threw an exception, I'm
+          # honestly not sure what the right thing to do is. For now I'll just
+          # print a warning. Should SafeYAML fail when Psych fails?
+          Kernel.warn "\n"
+          Kernel.warn "Discrepancy between SafeYAML and #{SafeYAML::YAML_ENGINE} on input:\n"
+          Kernel.warn "#{yaml.unindent}\n"
+          Kernel.warn "SafeYAML result:"
+          Kernel.warn "#{safe_result.inspect}\n"
+          Kernel.warn "#{SafeYAML::YAML_ENGINE} result:"
+          Kernel.warn "#{exception_thrown.inspect}\n"
+
+        else
+          expect(safe_result).to eq(unsafe_result)
+        end
+      end
+
+      context "by default" do
+        it "translates maps to hashes" do
+          parse <<-YAML
+            potayto: potahto
+            tomayto: tomahto
+          YAML
+
+          expect(result).to eq({
+            "potayto" => "potahto",
+            "tomayto" => "tomahto"
+          })
+        end
+
+        it "translates sequences to arrays" do
+          parse <<-YAML
+            - foo
+            - bar
+            - baz
+          YAML
+
+          expect(result).to eq(["foo", "bar", "baz"])
+        end
+
+        it "translates most values to strings" do
+          parse "string: value"
+          expect(result).to eq({ "string" => "value" })
+        end
+
+        it "does not deserialize symbols" do
+          parse ":symbol: value"
+          expect(result).to eq({ ":symbol" => "value" })
+        end
+
+        it "translates valid integral numbers to integers" do
+          parse "integer: 1"
+          expect(result).to eq({ "integer" => 1 })
+        end
+
+        it "translates valid decimal numbers to floats" do
+          parse "float: 3.14"
+          expect(result).to eq({ "float" => 3.14 })
+        end
+
+        it "translates valid dates" do
+          parse "date: 2013-01-24"
+          expect(result).to eq({ "date" => Date.parse("2013-01-24") })
+        end
+
+        it "translates valid true/false values to booleans" do
+          parse <<-YAML
+            - yes
+            - true
+            - no
+            - false
+          YAML
+
+          expect(result).to eq([true, true, false, false])
+        end
+
+        it "translates valid nulls to nil" do
+          parse <<-YAML
+            - 
+            - ~
+            - null
+          YAML
+
+          expect(result).to eq([nil] * 3)
+        end
+
+        it "matches the behavior of the underlying YAML engine w/ respect to capitalization of boolean values" do
+          parse_and_test <<-YAML
+            - true
+            - True
+            - TRUE
+            - tRue
+            - TRue
+            - False
+            - FALSE
+            - fAlse
+            - FALse
+          YAML
+
+          # using Syck: [true, true, true, "tRue", "TRue", false, false, "fAlse", "FALse"]
+          # using Psych: all booleans
+        end
+
+        it "matches the behavior of the underlying YAML engine w/ respect to capitalization of nil values" do
+          parse_and_test <<-YAML
+            - Null
+            - NULL
+            - nUll
+            - NUll
+          YAML
+
+          # using Syck: [nil, nil, "nUll", "NUll"]
+          # using Psych: all nils
+        end
+
+        it "translates quoted empty strings to strings (not nil)" do
+          parse "foo: ''"
+          expect(result).to eq({ "foo" => "" })
+        end
+
+        it "correctly reverse-translates strings encoded via #to_yaml" do
+          parse "5.10".to_yaml
+          expect(result).to eq("5.10")
+        end
+
+        it "does not specially parse any double-quoted strings" do
+          parse <<-YAML
+            - "1"
+            - "3.14"
+            - "true"
+            - "false"
+            - "2013-02-03"
+            - "2013-02-03 16:27:00 -0600"
+          YAML
+
+          expect(result).to eq(["1", "3.14", "true", "false", "2013-02-03", "2013-02-03 16:27:00 -0600"])
+        end
+
+        it "does not specially parse any single-quoted strings" do
+          parse <<-YAML
+            - '1'
+            - '3.14'
+            - 'true'
+            - 'false'
+            - '2013-02-03'
+            - '2013-02-03 16:27:00 -0600'
+          YAML
+
+          expect(result).to eq(["1", "3.14", "true", "false", "2013-02-03", "2013-02-03 16:27:00 -0600"])
+        end
+
+        it "deals just fine with nested maps" do
+          parse <<-YAML
+            foo:
+              bar:
+                marco: polo
+          YAML
+
+          expect(result).to eq({ "foo" => { "bar" => { "marco" => "polo" } } })
+        end
+
+        it "deals just fine with nested sequences" do
+          parse <<-YAML
+            - foo
+            -
+              - bar1
+              - bar2
+              -
+                - baz1
+                - baz2
+          YAML
+
+          expect(result).to eq(["foo", ["bar1", "bar2", ["baz1", "baz2"]]])
+        end
+
+        it "applies the same transformations to keys as to values" do
+          parse <<-YAML
+            foo: string
+            :bar: symbol
+            1: integer
+            3.14: float
+            2013-01-24: date
+          YAML
+
+          expect(result).to eq({
+            "foo"  => "string",
+            ":bar" => "symbol",
+            1      => "integer",
+            3.14   => "float",
+            Date.parse("2013-01-24") => "date",
+          })
+        end
+
+        it "applies the same transformations to elements in sequences as to all values" do
+          parse <<-YAML
+            - foo
+            - :bar
+            - 1
+            - 3.14
+            - 2013-01-24
+          YAML
+
+          expect(result).to eq(["foo", ":bar", 1, 3.14, Date.parse("2013-01-24")])
+        end
+      end
+
+      context "for Ruby version #{RUBY_VERSION}" do
+        it "translates valid time values" do
+          parse "time: 2013-01-29 05:58:00 -0800"
+          expect(result).to eq({ "time" => Time.utc(2013, 1, 29, 13, 58, 0) })
+        end
+
+        it "applies the same transformation to elements in sequences" do
+          parse "- 2013-01-29 05:58:00 -0800"
+          expect(result).to eq([Time.utc(2013, 1, 29, 13, 58, 0)])
+        end
+
+        it "applies the same transformation to keys" do
+          parse "2013-01-29 05:58:00 -0800: time"
+          expect(result).to eq({ Time.utc(2013, 1, 29, 13, 58, 0) => "time" })
+        end
+      end
+
+      context "with symbol deserialization enabled" do
+        before :each do
+          SafeYAML::OPTIONS[:deserialize_symbols] = true
+        end
+
+        after :each do
+          SafeYAML.restore_defaults!
+        end
+
+        it "translates values starting with ':' to symbols" do
+          parse "symbol: :value"
+          expect(result).to eq({ "symbol" => :value })
+        end
+
+        it "applies the same transformation to keys" do
+          parse ":bar: symbol"
+          expect(result).to eq({ :bar  => "symbol" })
+        end
+
+        it "applies the same transformation to elements in sequences" do
+          parse "- :bar"
+          expect(result).to eq([:bar])
+        end
+      end
+    end
+  end
+end