codeclimate-yaml 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dac3e3ac75a2d03d789a2f8a444e79e26045698b
+  data.tar.gz: c25e962bc3e09d8d9f1ebdbc151189c26ce69f8c
+SHA512:
+  metadata.gz: 8973baee70e58c3dbeddfd13fb45ba6d1ffadbd6e86ef79e932c36f71c853fcf1efdcdb35eb29fff6a66c44c92036ff18fe5074d799e20fa70bc6399b7e28fa6
+  data.tar.gz: 5f584e502651441c49993fba4743ad2d53473099f37ff7a57099a09f4febd9fddcd332e774974a827696c2bb1aa36fea04ee5d308bd44084c7266fae72c1d5e5

data/lib/cc/yaml.rb

@@ -0,0 +1,26 @@
+module CC
+  module Yaml
+    autoload :Nodes, "cc/yaml/nodes"
+    autoload :Parser, "cc/yaml/parser"
+    autoload :Serializer, "cc/yaml/serializer"
+
+    def self.parse(value)
+      Parser.parse(value)
+    end
+
+    def self.parse!(value, file_name = ".codeclimate.yml", logger = Kernel)
+      result = parse(value)
+
+      result.nested_warnings.each do |key, message|
+        logger.warn key.empty? ? "#{file_name}: #{message}" :
+          "#{file_name}: #{key.join(?.)} section - #{message}"
+      end
+
+      result
+    end
+
+    def self.new
+      Nodes::Root.new
+    end
+  end
+end

data/lib/cc/yaml/nodes.rb

@@ -0,0 +1,23 @@
+module CC
+  module Yaml
+    module Nodes
+      autoload :Engine, "cc/yaml/nodes/engine"
+      autoload :EngineList, "cc/yaml/nodes/engine_list"
+      autoload :ExcludePath, "cc/yaml/nodes/exclude_path"
+      autoload :ExcludePathList, "cc/yaml/nodes/exclude_path_list"
+      autoload :Mapping, "cc/yaml/nodes/mapping"
+      autoload :Node, "cc/yaml/nodes/node"
+      autoload :OpenMapping, "cc/yaml/nodes/open_mapping"
+      autoload :Root, "cc/yaml/nodes/root"
+      autoload :Scalar, "cc/yaml/nodes/scalar"
+      autoload :Sequence, "cc/yaml/nodes/sequence"
+
+      def self.[](key)
+        return key if key.respond_to? :new
+        name = constants.detect { |c| c.downcase == key }
+        raise ArgumentError, "unknown node type %p" % key unless name
+        const_get(name)
+      end
+    end
+  end
+end

data/lib/cc/yaml/nodes/engine.rb

@@ -0,0 +1,9 @@
+module CC
+  module Yaml
+    module Nodes
+      class Engine < Mapping
+        map :enabled, to: Scalar[:bool], required: true
+      end
+    end
+  end
+end

data/lib/cc/yaml/nodes/engine_list.rb

@@ -0,0 +1,9 @@
+module CC
+  module Yaml
+    module Nodes
+      class EngineList < OpenMapping
+        default_type Engine
+      end
+    end
+  end
+end

data/lib/cc/yaml/nodes/exclude_path.rb

@@ -0,0 +1,8 @@
+module CC
+  module Yaml
+    module Nodes
+      class ExcludePath < Scalar
+      end
+    end
+  end
+end

data/lib/cc/yaml/nodes/exclude_path_list.rb

@@ -0,0 +1,9 @@
+module CC
+  module Yaml
+    module Nodes
+      class ExcludePathList < Sequence
+        type ExcludePath
+      end
+    end
+  end
+end

data/lib/cc/yaml/nodes/mapping.rb

@@ -0,0 +1,173 @@
+module CC::Yaml
+  module Nodes
+    class Mapping < Node
+      def self.mapping
+        @mapping ||= superclass.respond_to?(:mapping) ? superclass.mapping.dup : {}
+      end
+
+      def self.required
+        @required ||= superclass.respond_to?(:required) ? superclass.required.dup : []
+      end
+
+      def self.aliases
+        @aliases ||= superclass.respond_to?(:aliases) ? superclass.aliases.dup : {}
+      end
+
+      def self.map(*list)
+        options = Hash === list.last ? list.pop : {}
+        list.each do |key|
+          required     << key.to_s if options[:required]
+          define_map_accessor(key)
+          case options[:to]
+          when Symbol then aliases[key.to_s] = options[:to].to_s
+          when Module then mapping[key.to_s] = options[:to]
+          when nil    then mapping[key.to_s] = Nodes[key]
+          else raise ArgumentError, 'unexpected value for to: %p' % options[:to]
+          end
+        end
+      end
+
+      def self.define_map_accessor(key)
+        define_method(key)       { | | self[key]       } unless method_defined? key
+        define_method("#{key}=") { |v| self[key] = v   } unless method_defined? "#{key}="
+        define_method("#{key}?") { | | !!self[key]     } unless method_defined? "#{key}?"
+      end
+
+      def self.subnode_for(key)
+        mapping[aliases.fetch(key.to_s, key.to_s)]
+      end
+
+      attr_reader :mapping
+      alias_method :__getobj__, :mapping
+
+      def prepare
+        @mapping = {}
+        super
+      end
+
+      def visit_mapping(visitor, value)
+        visitor.apply_mapping(self, value)
+      end
+
+      def visit_pair(visitor, key, value)
+        key = visitor.generate_key(self, key)
+        visit_key_value(visitor, key, value)
+      end
+
+      def visit_key_value(visitor, key, value)
+        return warning("unexpected key %p, dropping", key) unless node = subnode_for(key)
+        warning("has multiple %p entries, keeping last entry", key) if self[key]
+        self[key] = node
+        visitor.accept(node, value)
+      end
+
+      def []=(key, value)
+        if mapped_key = mapped_key(key)
+          unless value.is_a? Node
+            node  = subnode_for(mapped_key)
+            value = node if Parser::Ruby.new(value).parse(node)
+          end
+          @mapping[mapped_key] = value
+        else
+          warning("unexpected key %p, dropping", key)
+        end
+      end
+
+      def [](key)
+        @mapping[mapped_key(key)]
+      end
+
+      def include?(key)
+        @mapping.include? mapped_key(key)
+      end
+
+      def empty?
+        @mapping.empty?
+      end
+
+      def mapped_key(key)
+        key = self.class.aliases.fetch(key.to_s, key.to_s)
+        key if accept_key?(key)
+      end
+
+      def accept_key?(key)
+        self.class.mapping.include? key
+      end
+
+      def subnode_for(key)
+        type = self.class.subnode_for(key)
+        type.new(self) if type
+      end
+
+      def inspect
+        @mapping.inspect
+      end
+
+      def ==(other)
+        other = other.mapping if other.is_a? Mapping
+        if other.respond_to? :to_hash and other.to_hash.size == @mapping.size
+          other.to_hash.all? { |k, v| include?(k) and self[k] == v }
+        else
+          false
+        end
+      end
+
+      def verify
+        verify_errors
+        verify_required
+        verify_errors
+      end
+
+      def verify_required
+        self.class.required.each do |key|
+          next if @mapping.include? key
+          type = self.class.subnode_for(key)
+          if type.has_default?
+            warning "missing key %p, defaulting to %p", key, type.default
+            @mapping[key] = type.new(self)
+          else
+            error "missing key %p", key
+          end
+        end
+      end
+
+      def verify_errors
+        @mapping.delete_if do |key, value|
+          if value.errors?
+            warning "dropping %p section: %s", key, value.errors.join(', ')
+            true
+          end
+        end
+      end
+
+      def deep_verify
+        @mapping.each_value(&:deep_verify)
+        super
+      end
+
+      def nested_warnings(*prefix)
+        @mapping.inject(super) do |list, (key, value)|
+          list = value.nested_warnings(*prefix, key) + list
+        end
+      end
+
+      def with_value!(value)
+        value = value.mapping while value.is_a? Mapping
+        value.each { |key, value| self[key] = value }
+      end
+
+      def each_scalar(type = nil, &block)
+        return enum_for(:each_scalar, type) unless block
+        @mapping.each_value { |v| v.each_scalar(type, &block) }
+      end
+
+      protected
+
+        def dup_values
+          duped_mapping = @mapping.map { |key, value| [key.dup, value.dup] }
+          @mapping      = Hash[duped_mapping]
+          self
+        end
+    end
+  end
+end

data/lib/cc/yaml/nodes/node.rb

@@ -0,0 +1,122 @@
+module CC
+  module Yaml
+    module Nodes
+      class Node
+        def self.has_default?
+          false
+        end
+
+        attr_accessor :parent
+
+        def initialize(parent)
+          @nested_warnings = []
+          @parent          = parent
+          prepare
+          yield self if block_given?
+        end
+
+        def warnings?
+          warnings.any?
+        end
+
+        def errors?
+          errors.any?
+        end
+
+        def warnings
+          @warnings ||= []
+        end
+
+        def nested_warning(message, *prefix)
+          @nested_warnings << [prefix, message]
+        end
+
+        def nested_warnings(*prefix)
+          messages  = errors + warnings
+          prefixed  = messages.map { |warning| [prefix, warning] }
+          prefixed += @nested_warnings.map { |p, w| [prefix + p, w] }
+          prefixed
+        end
+
+        def errors
+          @errors ||= []
+        end
+
+        def warning(message, *params)
+          warnings << message % params
+        end
+
+        def error(message, *params)
+          errors << message % params
+        end
+
+        def prepare
+        end
+
+        def verify
+        end
+
+        def deep_verify
+          verify
+        end
+
+        def visit_unexpected(visitor, value, message = nil)
+          error(message || "unexpected %p", value)
+        end
+
+        def visit_mapping(visitor, value)
+          error("unexpected mapping")
+        end
+
+        def visit_pair(visitor, key, value)
+          error("unexpected pair")
+        end
+
+        def visit_scalar(visitor, type, value, implicit = true)
+          error("unexpected scalar") unless type == :null
+        end
+
+        def visit_sequence(visitor, value)
+          error("unexpected sequence")
+        end
+
+        def visit_child(visitor, value)
+          error("unexpected child")
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          __getobj__.respond_to?(method, false)
+        end
+
+        def method_missing(method, *args, &block)
+          return super unless __getobj__.respond_to?(method)
+          __getobj__.public_send(method, *args, &block)
+        end
+
+        def to_s
+          __getobj__.to_s
+        end
+
+        def to_json(options = nil)
+          Serializer::Json.serialize(self, options)
+        end
+
+        def with_value(value)
+          node = dup
+          node.with_value!(value)
+          node
+        end
+
+        def dup
+          super.dup_values
+        end
+
+        protected
+
+          def dup_values
+            self
+          end
+      end
+    end
+  end
+end

data/lib/cc/yaml/nodes/open_mapping.rb

@@ -0,0 +1,18 @@
+module CC::Yaml
+  module Nodes
+    class OpenMapping < Mapping
+      def self.default_type(identifier = nil)
+        @default_type = Nodes[identifier] if identifier
+        @default_type ||= superclass.respond_to?(:default_type) ? superclass.default_type : Scalar
+      end
+
+      def self.subnode_for(key)
+        super(key) || default_type
+      end
+
+      def accept_key?(key)
+        true
+      end
+    end
+  end
+end

data/lib/cc/yaml/nodes/root.rb

@@ -0,0 +1,22 @@
+module CC
+  module Yaml
+    module Nodes
+      class Root < Mapping
+        map :exclude_paths, to: ExcludePathList
+        map :engines, to: EngineList
+
+        def initialize
+          super(nil)
+        end
+
+        def nested_warnings(*)
+          super.uniq
+        end
+
+        def inspect
+          "#<#{self.class.name}:#{super}>"
+        end
+      end
+    end
+  end
+end

data/lib/cc/yaml/nodes/scalar.rb

@@ -0,0 +1,112 @@
+module CC::Yaml
+  module Nodes
+    class Scalar < Node
+      def self.[](*types)
+        Class.new(self) do
+          default_type(types.first)
+          cast(*types)
+        end
+      end
+
+      def self.cast?(type)
+        cast.include? type
+      end
+
+      def self.cast(*types)
+        @cast ||= superclass.respond_to?(:cast) ? superclass.cast.dup : []
+        @cast.concat(types) if types.any?
+        @cast
+      end
+
+      def self.default_type(type = nil)
+        @default_type = type if type
+        @default_type ||= superclass.respond_to?(:default_type) ? superclass.default_type : :str
+      end
+
+      def self.default(value = nil)
+        @default = value if value
+        @default ||= nil
+      end
+
+      def self.has_default?
+        !default.nil?
+      end
+
+      attr_accessor :value
+      alias_method :__getobj__, :value
+
+      def empty?
+        value.nil?
+      end
+
+      def prepare
+        self.value = self.class.default
+        @multiple  = false
+        super
+      end
+
+      def ==(other)
+        other = other.value if other.is_a? self.class
+        other == value
+      end
+
+      def default_type
+        self.class.default_type
+      end
+
+      def inspect
+        value.inspect
+      end
+
+      def visit_scalar(visitor, type, value, implicit = true)
+        return self.value = cast(visitor, type,         value) if cast? type
+        return self.value = cast(visitor, default_type, value) if implicit
+        error "%p not supported, dropping %p", type.to_s, cast(visitor, :str, value)
+      end
+
+      def visit_sequence(visitor, value)
+        @multiple = false
+        visitor.apply_sequence(self, value)
+      end
+
+      def visit_child(visitor, value)
+        if @multiple
+          value = cast(visitor, :str, value) rescue value
+          warning "does not support multiple values, dropping %p", value
+        else
+          @multiple = true
+          visitor.accept(self, value)
+        end
+      end
+
+      def cast(visitor, type, value)
+        visitor.cast(type, value)
+      rescue ArgumentError => error
+        error "failed to parse %p - %s", type.to_s, error.message.sub("():", ":")
+      end
+
+      def cast?(type)
+        self.class.cast?(type) or type == default_type
+      end
+
+      def !@
+        !value
+      end
+
+      def with_value(value)
+        return value.dup if value.is_a? self.class
+        value = value.value while value.is_a? Scalar
+        super(value)
+      end
+
+      def with_value!(value)
+        self.value = value
+      end
+
+      def each_scalar(type = nil, &block)
+        return enum_for(:each_scalar, type) unless block
+        yield value if type.nil? or type === value
+      end
+    end
+  end
+end

data/lib/cc/yaml/nodes/sequence.rb

@@ -0,0 +1,122 @@
+module CC::Yaml
+  module Nodes
+    class Sequence < Node
+      attr_reader :children
+      alias_method :__getobj__, :children
+
+      def self.[](node_type)
+        node_type = Scalar[node_type] unless node_type.is_a? Node
+        Class.new(self) { type(node_type) }
+      end
+
+      def self.type(identifier = nil)
+        @type = Nodes[identifier] if identifier
+        @type ||= superclass.respond_to?(:type) ? superclass.type : Scalar
+      end
+
+      def prepare
+        @children = []
+      end
+
+      def visit_sequence(visitor, value)
+        visitor.apply_sequence(self, value)
+      end
+
+      def visit_scalar(visitor, type, value, implicit = true)
+        visit_child(visitor, value) if type != :null
+      end
+
+      def visit_mapping(visitor, value)
+        visit_child(visitor, value)
+      end
+
+      def visit_child(visitor, value)
+        child = self.class.type.new(self)
+        visitor.accept(child, value)
+        @children << child
+      end
+
+      def nested_warnings(*prefix)
+        @children.inject(super) do |list, value|
+          list = value.nested_warnings(*prefix) + list
+        end
+      end
+
+      def ==(other)
+        other = other.children if other.is_a? Sequence
+        if other.respond_to? :to_a and other.to_a.size == children.size
+          children.zip(other.to_a).all? { |a, b| a == b }
+        else
+          identifier == other
+        end
+      end
+
+      def empty?
+        @children.empty?
+      end
+
+      def inspect
+        identifier.inspect
+      end
+
+      def to_s
+        identifier.to_s
+      end
+
+      def identifier
+        @children.size == 1 ? @children.first : @children
+      end
+
+      def verify
+        verify_children
+        super
+      end
+
+      def verify_children
+        @children.delete_if do |child|
+          next unless child.errors?
+          child.errors.each { |message| warning(message) }
+          true
+        end
+      end
+
+      def deep_verify
+        @children.each(&:deep_verify)
+        super
+      end
+
+      def each_scalar(type = nil, &block)
+        return enum_for(:each_scalar, type) unless block
+        @children.each { |c| c.each_scalar(type, &block) }
+      end
+
+      def with_value(value)
+        return value.dup if value.is_a? self.class
+        value = value.children if value.is_a? Sequence
+        value = value.value while value.is_a? Scalar
+        Parser::Ruby.new(Array(value)).parse self.class.new(parent)
+      end
+
+      def with_value!(value)
+        children.replace with_value(value).children
+      end
+
+      def add_value(value)
+        added = with_value(self)
+        added.add_value!(value)
+        added
+      end
+
+      def add_value!(value)
+        children.concat(with_value(value).children)
+      end
+
+      protected
+
+        def dup_values
+          @children = @children.map { |child| child.dup }
+          self
+        end
+    end
+  end
+end

data/lib/cc/yaml/parser.rb

@@ -0,0 +1,11 @@
+module CC
+  module Yaml
+    module Parser
+      autoload :Psych, "cc/yaml/parser/psych"
+
+      def self.parse(value)
+        Psych.parse(value)
+      end
+    end
+  end
+end

data/lib/cc/yaml/parser/psych.rb

@@ -0,0 +1,223 @@
+require 'psych'
+require 'delegate'
+
+module CC::Yaml
+  module Parser
+    class Psych
+      class SetNode < DelegateClass(::Psych::Nodes::Mapping)
+        def children
+          super.select.with_index { |_,i| i.even? }
+        end
+      end
+
+      class ScalarSequence < DelegateClass(::Psych::Nodes::Mapping)
+        def children
+          [__getobj__]
+        end
+      end
+
+      MAP       = /\A(?:tag:yaml\.org,2002:|!!?)map\z/
+      OMAP      = /\A(?:tag:yaml\.org,2002:|!!?)omap\z/
+      PAIRS     = /\A(?:tag:yaml\.org,2002:|!!?)pairs\z/
+      SET       = /\A(?:tag:yaml\.org,2002:|!!?)set\z/
+      SEQ       = /\A(?:tag:yaml\.org,2002:|!!?)seq\z/
+      BINARY    = /\A(?:tag:yaml\.org,2002:|!!?)binary\z/
+      BOOL      = /\A(?:tag:yaml\.org,2002:|!!?)bool\z/
+      FLOAT     = /\A(?:tag:yaml\.org,2002:|!!?)float\z/
+      INT       = /\A(?:tag:yaml\.org,2002:|!!?)int\z/
+      MERGE     = /\A(?:tag:yaml\.org,2002:|!!?)merge\z/
+      NULL      = /\A(?:tag:yaml\.org,2002:|!!?)null\z/
+      STR       = /\A(?:tag:yaml\.org,2002:|!!?)str\z/
+      TIMESTAMP = /\A(?:tag:yaml\.org,2002:|!!?)timestamp\z/
+      VALUE     = /\A(?:tag:yaml\.org,2002:|!!?)value\z/
+      YAML      = /\A(?:tag:yaml\.org,2002:|!!?)yaml\z/
+      SECURE    = /\A!(?:encrypted|secure|decrypted)\z/
+      TRUE      = /\A(?:y|Y|yes|Yes|YES|true|True|TRUE|on|On|ON)\z/
+      FALSE     = /\A(?:n|N|no|No|NO|false|False|FALSE|off|Off|OFF)\z/
+      REGEXP    = /\A!(?:ruby\/)?regexp\z/
+      REG_FLAGS = { 'i' => Regexp::IGNORECASE, 'm' => Regexp::MULTILINE, 'x' => Regexp::EXTENDED }
+      FORMATS   = {
+        '!bool'      => Regexp.union(TRUE, FALSE),
+        '!float'     => ::Psych::ScalarScanner::FLOAT,
+        '!null'      => /\A(:?~|null|Null|NULL|)\z/,
+        '!timestamp' => ::Psych::ScalarScanner::TIME,
+        '!int'       => ::Psych::ScalarScanner::INTEGER,
+        '!regexp'    => /\A\/(.*)\/([imx]*)\z/
+      }
+
+      if defined? ::Psych::ClassLoader
+        CLASS_LOADER = ::Psych::ClassLoader.new
+        class ScalarScanner < ::Psych::ScalarScanner
+          def initialize
+            super(CLASS_LOADER)
+          end
+        end
+      else
+        ScalarScanner = ::Psych::ScalarScanner
+      end
+
+      def self.parses?(value)
+        return true if value.is_a?(::Psych::Nodes::Node)
+        return true if value.is_a?(String) or value.is_a?(IO)
+        return true if defined?(StringIO) and value.is_a?(StringIO)
+        value.respond_to?(:to_str) or value.respond_to?(:to_io)
+      end
+
+      def self.parse(value)
+        new(value).parse
+      end
+
+      def initialize(value)
+        value    = value.to_str if value.respond_to? :to_str
+        value    = value.to_io  if value.respond_to? :to_io
+        @value   = value
+        @scanner = ScalarScanner.new
+      end
+
+      def parse(root = nil)
+        root   ||= CC::Yaml::Nodes::Root.new
+        parsed   = @value if @value.is_a? ::Psych::Nodes::Node
+        parsed ||= ::Psych.parse(@value)
+        accept(root, parsed)
+        root
+      rescue ::Psych::SyntaxError => error
+        root.verify
+        root.warnings.clear
+        root.error("syntax error: %s", error.message)
+        root
+      end
+
+      def accept(node, value)
+        case value
+        when ::Psych::Nodes::Scalar   then accept_scalar   node, value
+        when ::Psych::Nodes::Mapping  then accept_mapping  node, value
+        when ::Psych::Nodes::Sequence then accept_sequence node, value
+        when ::Psych::Nodes::Alias    then accept_alias    node, value
+        when ::Psych::Nodes::Document then accept          node, value.root
+        when ::Psych::Nodes::Stream   then accept_sequence node, value
+        else node.visit_unexpected(self, value) if value
+        end
+        node.verify
+      end
+
+      def accept_sequence(node, value)
+        case value.tag
+        when SET, SEQ
+          node.visit_sequence self, value
+        when nil
+          value = ScalarSequence.new(value) unless value.is_a? ::Psych::Nodes::Sequence
+          node.visit_sequence self, value
+        else
+          node.visit_sequence self, ScalarSequence.new(value)
+        end
+      end
+
+      def accept_mapping(node, value)
+        case value.tag
+        when MAP, OMAP, PAIRS then node.visit_mapping  self, value
+        when SET              then node.visit_sequence self, SetNode.new(value)
+        when SEQ              then node.visit_sequence self, value
+        when nil
+          if value.children.size == 2 and value.children.first.value == 'secure'
+            secret_value = value.children.last
+            if secret_value.is_a? ::Psych::Nodes::Scalar
+              secret_value.tag ||= '!secure'
+              node.visit_scalar(self, :secure, secret_value, false)
+            else
+              node.visit_unexpected(self, value, "secret value needs to be a string")
+            end
+          else
+            node.visit_mapping(self, value)
+          end
+        else
+          node.visit_unexpected self, value, "unexpected tag %p for mapping" % value.tag
+        end
+      end
+
+      def accept_scalar(node, value)
+        case tag = scalar_tag(value)
+        when BINARY    then node.visit_scalar self, :binary, value, value.tag.nil?
+        when BOOL      then node.visit_scalar self, :bool,   value, value.tag.nil?
+        when FLOAT     then node.visit_scalar self, :float,  value, value.tag.nil?
+        when INT       then node.visit_scalar self, :int,    value, value.tag.nil?
+        when NULL      then node.visit_scalar self, :null,   value, value.tag.nil?
+        when STR       then node.visit_scalar self, :str,    value, value.tag.nil?
+        when TIMESTAMP then node.visit_scalar self, :time,   value, value.tag.nil?
+        when SECURE    then node.visit_scalar self, :secure, value, value.tag.nil?
+        when NULL      then node.visit_scalar self, :null,   value, value.tag.nil?
+        when REGEXP    then node.visit_scalar self, :regexp, value, value.tag.nil?
+        else node.visit_unexpected self, value, "unexpected tag %p for scalar %p" % [tag, simple(value)]
+        end
+      end
+
+      def simple(value)
+        case value
+        when ::Psych::Nodes::Scalar   then value.value
+        when ::Psych::Nodes::Mapping  then simple_mapping(value)
+        when ::Psych::Nodes::Sequence then value.children.map { |c| simple(c) }
+        when ::Psych::Nodes::Document then simple(value.root)
+        when ::Psych::Nodes::Stream   then value.children.map { |c| simple(c) }
+        else value
+        end
+      end
+
+      def simple_mapping(value)
+        children     = {}
+        keys, values = value.children.group_by.with_index { |_,i| i.even? }.values_at(true, false)
+        keys.zip(values) { |key, value| children[simple(key)] = simple(value) } if keys and values
+        children
+      end
+
+      def scalar_tag(value)
+        return value.tag if value.tag
+        return '!str' if value.quoted
+        FORMATS.each do |tag, format|
+          return tag if value.value =~ format
+        end
+        '!str'
+      end
+
+      def regexp(pattern)
+        return pattern if pattern.is_a? Regexp
+        return Regexp.new(pattern) unless pattern =~ FORMATS['!regexp']
+        flag = $2.chars.inject(0) { |f,c| f | REG_FLAGS.fetch(c, 0) }
+        Regexp.new($1, flag)
+      rescue RegexpError => error
+        raise ArgumentError, "broken regular expression - #{error.message}"
+      end
+
+      def cast(type, value)
+        case type
+        when :str    then value.value
+        when :binary then value.value.unpack('m').first
+        when :bool   then value.value !~ FALSE
+        when :float  then Float   @scanner.tokenize(value.value)
+        when :int    then Integer @scanner.tokenize(value.value)
+        when :time   then @scanner.parse_time(value.value)
+        when :secure then SecureString.new(value.value, value.tag != '!decrypted')
+        when :regexp then regexp(value.value)
+        when :null   then nil
+        else raise ArgumentError, 'unknown scalar type %p' % type
+        end
+      end
+
+      def apply_mapping(node, value)
+        keys, values = value.children.group_by.with_index { |_,i| i.even? }.values_at(true, false)
+        keys.zip(values) { |key, value| node.visit_pair(self, key, value) } if keys and values
+      end
+
+      def apply_sequence(node, value)
+        value.children.each { |child| node.visit_child(self, child) }
+      end
+
+      def generate_key(node, value)
+        if value.respond_to? :value and (value.tag.nil? || value.tag == STR)
+          value = value.value.to_s
+          value.start_with?(?:) ? value[1..-1] : value
+        else
+          node.visit_unexpected(self, value, "expected string as key")
+        end
+      end
+    end
+  end
+end

data/lib/cc/yaml/serializer.rb

@@ -0,0 +1,10 @@
+module CC
+  module Yaml
+    module Serializer
+      NotSupportedError = Class.new(ArgumentError)
+
+      autoload :Generic, "cc/yaml/serializer/generic"
+      autoload :Json, "cc/yaml/serializer/json"
+    end
+  end
+end

data/lib/cc/yaml/serializer/generic.rb

@@ -0,0 +1,114 @@
+module CC::Yaml
+  module Serializer
+    class Generic
+      attr_reader :options
+
+      def self.serialize(node, options = nil)
+        new(options).serialize(node)
+      end
+
+      def initialize(options = nil)
+        @options = options || {}
+      end
+
+      def symbol_keys?
+        !!options[:symbol_keys]
+      end
+
+      def serialize(node)
+        case node
+        when Nodes::Root     then serialize_root(node)
+        when Nodes::Scalar   then serialize_scalar(node)
+        when Nodes::Mapping  then serialize_mapping(node)
+        when Nodes::Sequence then serialize_sequence(node)
+        else raise NotSupportedError, 'do not know how to serialize %p' % node.class
+        end
+      end
+
+      def serialize_scalar(node)
+        case value = node.value
+        when true, false  then serialize_bool(value)
+        when Float        then serialize_float(value)
+        when Integer      then serialize_integer(value)
+        when Time         then serialize_time(value)
+        when SecureString then serialize_secure(value)
+        when Regexp       then serialize_regexp(value)
+        when String
+          value.encoding == Encoding::BINARY ? serialize_binary(value) : serialize_str(value)
+        else
+          serialize_value(node)
+        end
+      end
+
+      def serialize_bool(value)
+        serialize_value(value)
+      end
+
+      def serialize_float(value)
+        serialize_value(value)
+      end
+
+      def serialize_time(value)
+        serialize_value(value)
+      end
+
+      def serialize_secure(value)
+        case options[:secure]
+        when :decrypted
+          raise ArgumentError, 'secure option is set decrypted, but a secure value is not decrypted' unless value.decrypted?
+          serialize_decrypted(value)
+        when :encrypted
+          raise ArgumentError, 'secure option is set encrypted, but a secure value is not encrypted' unless value.encrypted?
+          serialize_encrypted(value)
+        else
+          raise ArgumentError, 'unexpected value for secure option: %p' % options[:secure] if options[:secure]
+          value.encrypted? ? serialize_encrypted(value) : serialize_decrypted(value)
+        end
+      end
+
+      def serialize_encrypted(value)
+        serialize_value(value)
+      end
+
+      def serialize_decrypted(value)
+        serialize_value(value)
+      end
+
+      def serialize_regexp(value)
+        serialize_value(value)
+      end
+
+      def serialize_str(value)
+        serialize_value(value)
+      end
+
+      def serialize_binary(value)
+        serialize_str(value)
+      end
+
+      def serialize_bool(value)
+        serialize_value(value)
+      end
+
+      def serialize_value(node)
+        raise NotSupportedError, 'cannot serialize %p with %p' % [node.class, self.class]
+      end
+
+      def serialize_root(node)
+        serialize_mapping(node)
+      end
+
+      def serialize_mapping(node)
+        node.map { |key, value| [serialize_key(key), serialize(value)] }
+      end
+
+      def serialize_sequence(node)
+        node.map { |value| serialize(value) }
+      end
+
+      def serialize_key(value)
+        symbol_keys? ? value.to_sym : value.to_s
+      end
+    end
+  end
+end

data/lib/cc/yaml/serializer/json.rb

@@ -0,0 +1,74 @@
+module CC
+  module Yaml
+    module Serializer
+      class Json < Generic
+        MAP = { # mapping stolen from json gem
+        "\x0"  => '\u0000', "\x1"  => '\u0001', "\x2"  => '\u0002', "\x3"  => '\u0003', "\x4"  => '\u0004', "\x5"  => '\u0005',
+        "\x6"  => '\u0006', "\x7"  => '\u0007', "\b"   =>  '\b',    "\t"   =>  '\t',    "\n"   => '\n',     "\xb"  => '\u000b',
+        "\f"   => '\f',     "\r"   =>  '\r',    "\xe"  => '\u000e', "\xf"  => '\u000f', "\x10" => '\u0010', "\x11" => '\u0011',
+        "\x12" => '\u0012', "\x13" => '\u0013', "\x14" => '\u0014', "\x15" => '\u0015', "\x16" => '\u0016', "\x17" => '\u0017',
+        "\x18" => '\u0018', "\x19" => '\u0019', "\x1a" => '\u001a', "\x1b" => '\u001b', "\x1c" => '\u001c', "\x1d" => '\u001d',
+        "\x1e" => '\u001e', "\x1f" => '\u001f', '"'    =>  '\"',    '\\'   =>  '\\\\'
+      }
+
+      def pretty?
+        !!options[:pretty]
+      end
+
+      def serialize_float(value)
+        raise NotSupportedError, 'cannot serialize infinity as JSON' if value.infinite?
+        "#{value}"
+      end
+
+      def serialize_encrypted(value)
+        key_value("secure", serialize_str(value.encrypted_string), "{%s}")
+      end
+
+      def serialize_decrypted(value)
+        serialize_str(value.decrypted_string)
+      end
+
+      def serialize_str(value)
+        string = value.encode('utf-8')
+        string.force_encoding('binary')
+        string.gsub!(/["\\\x0-\x1f]/) { MAP[$&] }
+        string.force_encoding('utf-8')
+        "\"#{string}\""
+      end
+
+      def serialize_binary(value)
+        raise NotSupportedError, 'cannot serialize binary data as JSON'
+      end
+
+      def serialize_bool(value)
+        value ? "true" : "false"
+      end
+
+      def serialize_mapping(node)
+        lines('{%s}', super.map { |key, value| key_value(key, value) })
+      end
+
+      def serialize_sequence(node)
+        lines('[%s]', super)
+      end
+
+      def key_value(key, value, wrapper = "%s")
+        space = pretty? ? " " : ""
+        wrapper % "#{serialize_str(key)}:#{space}#{value}"
+      end
+
+      def lines(wrapper, lines)
+        return wrapper % lines.join(',') unless pretty?
+        return wrapper % "" if lines.empty?
+        return wrapper % " #{lines.first} " unless lines.size > 1 or  lines.first.include?("\n") or lines.first.size > 50
+        lines = "\n  " + lines.join(",\n").strip.gsub("\n", "\n  ") + "\n"
+        wrapper % lines
+      end
+
+      def serialize_key(value)
+        value.to_s
+      end
+      end
+    end
+  end
+end

data/lib/cc/yaml/version.rb

@@ -0,0 +1,5 @@
+module CC
+  module Yaml
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: codeclimate-yaml
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Code Climate
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-08 00:00:00.000000000 Z
+dependencies: []
+description: Code Climate YAML parser
+email: hello@codeclimate.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cc/yaml.rb
+- lib/cc/yaml/nodes.rb
+- lib/cc/yaml/nodes/engine.rb
+- lib/cc/yaml/nodes/engine_list.rb
+- lib/cc/yaml/nodes/exclude_path.rb
+- lib/cc/yaml/nodes/exclude_path_list.rb
+- lib/cc/yaml/nodes/mapping.rb
+- lib/cc/yaml/nodes/node.rb
+- lib/cc/yaml/nodes/open_mapping.rb
+- lib/cc/yaml/nodes/root.rb
+- lib/cc/yaml/nodes/scalar.rb
+- lib/cc/yaml/nodes/sequence.rb
+- lib/cc/yaml/parser.rb
+- lib/cc/yaml/parser/psych.rb
+- lib/cc/yaml/serializer.rb
+- lib/cc/yaml/serializer/generic.rb
+- lib/cc/yaml/serializer/json.rb
+- lib/cc/yaml/version.rb
+homepage: https://codeclimate.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Code Climate YAML
+test_files: []