amazing_print 1.6.0 → 1.7.2

data/spec/ext/mongo_mapper_spec.rb

@@ -1,265 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Lint/ConstantDefinitionInBlock
-
-require 'spec_helper'
-
-RSpec.describe 'AmazingPrint/MongoMapper', skip: -> { !ExtVerifier.has_mongo_mapper? }.call do
-  if ExtVerifier.has_mongo_mapper?
-    before :all do
-      class MongoUser
-        include MongoMapper::Document
-
-        key :first_name, String
-        key :last_name, String
-      end
-    end
-
-    after :all do
-      Object.instance_eval { remove_const :MongoUser }
-      Object.instance_eval { remove_const :Chamelion }
-    end
-  end
-
-  before do
-    @ap = AmazingPrint::Inspector.new(plain: true, sort_keys: true)
-  end
-
-  describe 'with the raw option set to true' do
-    # before { @ap.options[:raw] = true }
-    before { @ap = AmazingPrint::Inspector.new(plain: true, sort_keys: true, raw: true) }
-
-    it 'prints class instance' do
-      user = MongoUser.new(first_name: 'Al', last_name: 'Capone')
-
-      out = @ap.send(:awesome, user)
-               .gsub(/#<Proc:.+?>/, 'amazing_print_PROC_STUB')
-               .gsub(/BSON::ObjectId\('[\da-f]+?'\)/, "BSON::ObjectId('123456789')")
-
-      str = if MongoMapper::Version >= '0.13'
-              <<~EOS.strip
-                #<MongoUser:placeholder_id
-                    @__mm_default_keys = [
-                        [0] #<MongoMapper::Plugins::Keys::Key:placeholder_id
-                            @dynamic = false,
-                            @embeddable = false,
-                            @has_default = true,
-                            @is_id = true,
-                            @typecast = nil,
-                            attr_accessor :accessors = [],
-                            attr_accessor :default = amazing_print_PROC_STUB,
-                            attr_accessor :ivar = :@_id,
-                            attr_accessor :name = "_id",
-                            attr_accessor :options = {
-                                :default => amazing_print_PROC_STUB
-                            },
-                            attr_accessor :type = ObjectId < Object
-                        >
-                    ],
-                    @__mm_keys = {
-                               "_id" => #<MongoMapper::Plugins::Keys::Key:placeholder_id
-                            @dynamic = false,
-                            @embeddable = false,
-                            @has_default = true,
-                            @is_id = true,
-                            @typecast = nil,
-                            attr_accessor :accessors = [],
-                            attr_accessor :default = amazing_print_PROC_STUB,
-                            attr_accessor :ivar = :@_id,
-                            attr_accessor :name = "_id",
-                            attr_accessor :options = {
-                                :default => amazing_print_PROC_STUB
-                            },
-                            attr_accessor :type = ObjectId < Object
-                        >,
-                        "first_name" => #<MongoMapper::Plugins::Keys::Key:placeholder_id
-                            @dynamic = false,
-                            @embeddable = false,
-                            @has_default = false,
-                            @is_id = false,
-                            @typecast = nil,
-                            attr_accessor :accessors = [],
-                            attr_accessor :ivar = :@first_name,
-                            attr_accessor :name = "first_name",
-                            attr_accessor :options = {},
-                            attr_accessor :type = String < Object
-                        >,
-                         "last_name" => #<MongoMapper::Plugins::Keys::Key:placeholder_id
-                            @dynamic = false,
-                            @embeddable = false,
-                            @has_default = false,
-                            @is_id = false,
-                            @typecast = nil,
-                            attr_accessor :accessors = [],
-                            attr_accessor :ivar = :@last_name,
-                            attr_accessor :name = "last_name",
-                            attr_accessor :options = {},
-                            attr_accessor :type = String < Object
-                        >
-                    },
-                    @__mm_pre_cast = {
-                        "first_name" => "Al",
-                         "last_name" => "Capone"
-                    },
-                    @_dynamic_attributes = {},
-                    @_new = true,
-                    attr_accessor :_id = BSON::ObjectId('123456789'),
-                    attr_accessor :attributes = nil,
-                    attr_accessor :first_name = "Al",
-                    attr_accessor :last_name = "Capone",
-                    attr_reader :changed_attributes = {
-                        "first_name" => nil,
-                         "last_name" => nil
-                    }
-                >
-              EOS
-            else
-              <<~EOS.strip
-                #<MongoUser:placeholder_id
-                    @_new = true,
-                    attr_accessor :first_name = "Al",
-                    attr_accessor :last_name = "Capone",
-                    attr_reader :changed_attributes = {
-                        "first_name" => nil,
-                         "last_name" => nil
-                    },
-                    attr_reader :first_name_before_type_cast = "Al",
-                    attr_reader :last_name_before_type_cast = "Capone"
-                >
-              EOS
-            end
-      expect(out).to be_similar_to(str)
-    end
-
-    it 'prints the class' do
-      expect(@ap.send(:awesome, MongoUser)).to eq <<~EOS.strip
-        class MongoUser < Object {
-                   "_id" => :object_id,
-            "first_name" => :string,
-             "last_name" => :string
-        }
-      EOS
-    end
-
-    it 'prints the class when type is undefined' do
-      class Chamelion
-        include MongoMapper::Document
-        key :last_attribute
-      end
-
-      expect(@ap.send(:awesome, Chamelion)).to eq <<~EOS.strip
-        class Chamelion < Object {
-                       "_id" => :object_id,
-            "last_attribute" => :undefined
-        }
-      EOS
-    end
-  end
-
-  describe 'with associations' do
-    if ExtVerifier.has_mongo_mapper?
-      before :all do
-        class Child
-          include MongoMapper::EmbeddedDocument
-          key :data
-        end
-
-        class Sibling
-          include MongoMapper::Document
-          key :title
-        end
-
-        class Parent
-          include MongoMapper::Document
-          key :name
-
-          one :child
-          one :sibling
-        end
-      end
-    end
-
-    describe 'with show associations turned off (default)' do
-      it 'renders the class as normal' do
-        expect(@ap.send(:awesome, Parent)).to eq <<~EOS.strip
-          class Parent < Object {
-               "_id" => :object_id,
-              "name" => :undefined
-          }
-        EOS
-      end
-
-      it 'renders an instance as normal' do
-        parent = Parent.new(name: 'test')
-        out = @ap.send(:awesome, parent)
-        str = <<~EOS.strip
-          #<Parent:placeholder_id> {
-               "_id" => placeholder_bson_id,
-              "name" => "test"
-          }
-        EOS
-        expect(out).to be_similar_to(str)
-      end
-    end
-
-    describe 'with show associations turned on and inline embedded turned off' do
-      before do
-        @ap = AmazingPrint::Inspector.new(plain: true, mongo_mapper: { show_associations: true })
-      end
-
-      it 'renders the class with associations shown' do
-        expect(@ap.send(:awesome, Parent)).to eq <<~EOS.strip
-          class Parent < Object {
-                  "_id" => :object_id,
-                 "name" => :undefined,
-                "child" => embeds one Child,
-              "sibling" => one Sibling
-          }
-        EOS
-      end
-
-      it 'renders an instance with associations shown' do
-        parent = Parent.new(name: 'test')
-        out = @ap.send(:awesome, parent)
-        str = <<~EOS.strip
-          #<Parent:placeholder_id> {
-                  "_id" => placeholder_bson_id,
-                 "name" => "test",
-                "child" => embeds one Child,
-              "sibling" => one Sibling
-          }
-        EOS
-        expect(out).to be_similar_to(str)
-      end
-    end
-
-    describe 'with show associations turned on and inline embedded turned on' do
-      before do
-        @ap = AmazingPrint::Inspector.new plain: true,
-                                          mongo_mapper: {
-                                            show_associations: true,
-                                            inline_embedded: true
-                                          }
-      end
-
-      it 'renders an instance with associations shown and embeds there' do
-        parent = Parent.new(name: 'test', child: Child.new(data: 5))
-        out = @ap.send(:awesome, parent)
-        str = <<~EOS.strip
-          #<Parent:placeholder_id> {
-                  "_id" => placeholder_bson_id,
-                 "name" => "test",
-                "child" => embedded #<Child:placeholder_id> {
-                   "_id" => placeholder_bson_id,
-                  "data" => 5
-              },
-              "sibling" => one Sibling
-          }
-        EOS
-        expect(out).to be_similar_to(str)
-      end
-    end
-  end
-end
-
-# rubocop:enable Lint/ConstantDefinitionInBlock

data/spec/ext/mongoid_spec.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Lint/ConstantDefinitionInBlock
-
-require 'spec_helper'
-
-RSpec.describe 'AmazingPrint/Mongoid', skip: -> { !ExtVerifier.has_mongoid? }.call do
-  before do
-    @ap = AmazingPrint::Inspector.new plain: true, sort_keys: true
-  end
-
-  describe 'Document' do
-    if ExtVerifier.has_mongoid?
-      before :all do
-        class MongoUser
-          include Mongoid::Document
-
-          field :first_name, type: String
-          field :last_name,  type: String
-        end
-      end
-
-      after :all do
-        Object.instance_eval { remove_const :MongoUser }
-        Object.instance_eval { remove_const :Chamelion }
-      end
-    end
-
-    it 'prints class instance' do
-      user = MongoUser.new first_name: 'Al', last_name: 'Capone'
-      out = @ap.send :awesome, user
-
-      object_id = user.id.inspect
-      str = <<~EOS.strip
-        #<MongoUser:placeholder_id> {
-                   :_id => #{object_id},
-            :first_name => "Al",
-             :last_name => "Capone"
-        }
-      EOS
-      expect(out).to be_similar_to(str, { skip_bson: true })
-    end
-
-    it 'prints the class' do
-      class_spec = <<~EOS.strip
-        class MongoUser < Object {
-                   :_id => :"bson/object_id",
-            :first_name => :string,
-             :last_name => :string
-        }
-      EOS
-
-      expect(@ap.send(:awesome, MongoUser)).to eq class_spec
-    end
-
-    it 'prints the class when type is undefined' do
-      class Chamelion
-        include Mongoid::Document
-        field :last_attribute
-      end
-
-      class_spec = <<~EOS.strip
-        class Chamelion < Object {
-                       :_id => :"bson/object_id",
-            :last_attribute => :object
-        }
-      EOS
-
-      expect(@ap.send(:awesome, Chamelion)).to eq class_spec
-    end
-  end
-
-  describe 'Document with aliased fields' do
-    if ExtVerifier.has_mongoid?
-      before :all do
-        class MongoUser
-          include Mongoid::Document
-
-          field :fn, as: :first_name, type: String
-          field :ln, as: :last_name,  type: String
-        end
-      end
-
-      after :all do
-        Object.instance_eval { remove_const :MongoUser }
-        Object.instance_eval { remove_const :Chamelion }
-      end
-    end
-
-    it 'prints class instance' do
-      user = MongoUser.new first_name: 'Al', last_name: 'Capone'
-      out = @ap.send :awesome, user
-
-      object_id = user.id.inspect
-      str = <<~EOS.strip
-        #<MongoUser:placeholder_id> {
-                         :_id => #{object_id},
-            :"first_name(fn)" => "Al",
-             :"last_name(ln)" => "Capone"
-        }
-      EOS
-      expect(out).to be_similar_to(str, { skip_bson: true })
-    end
-
-    it 'prints the class' do
-      class_spec = <<~EOS.strip
-        class MongoUser < Object {
-                         :_id => :"bson/object_id",
-            :"first_name(fn)" => :string,
-             :"last_name(ln)" => :string
-        }
-      EOS
-
-      expect(@ap.send(:awesome, MongoUser)).to eq class_spec
-    end
-
-    it 'prints the class when type is undefined' do
-      class Chamelion
-        include Mongoid::Document
-        field :la, as: :last_attribute
-      end
-
-      class_spec = <<~EOS.strip
-        class Chamelion < Object {
-                             :_id => :"bson/object_id",
-            :"last_attribute(la)" => :object
-        }
-      EOS
-
-      expect(@ap.send(:awesome, Chamelion)).to eq class_spec
-    end
-  end
-end
-
-# rubocop:enable Lint/ConstantDefinitionInBlock

data/spec/ext/nobrainer_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Lint/ConstantDefinitionInBlock
-
-require 'spec_helper'
-
-RSpec.describe 'AmazingPrint/NoBrainer', skip: -> { !ExtVerifier.has_nobrainer? }.call do
-  if ExtVerifier.has_nobrainer?
-    before :all do
-      NoBrainer.configure do |config|
-        config.app_name = 'ap_test'
-        config.environment = :test
-      end
-    end
-
-    before :all do
-      class SomeModel
-        include NoBrainer::Document
-
-        field :first_name, type: String
-        field :last_name,  type: String
-        field :some_field
-      end
-    end
-
-    after :all do
-      Object.instance_eval { remove_const :SomeModel }
-    end
-  end
-
-  before do
-    @ap = AmazingPrint::Inspector.new plain: true
-  end
-
-  it 'prints class instance' do
-    user = SomeModel.new first_name: 'Al', last_name: 'Capone'
-    out = @ap.send :awesome, user
-
-    object_id = user.id.inspect
-    str = <<~EOS.strip
-      #<SomeModel id: #{object_id}> {
-                  :id => #{object_id},
-          :first_name => "Al",
-           :last_name => "Capone"
-      }
-    EOS
-    expect(out).to eq(str)
-  end
-
-  it 'prints the class' do
-    class_spec = <<~EOS.strip
-      class SomeModel < Object {
-                  :id => :string,
-          :first_name => :string,
-           :last_name => :string,
-          :some_field => :object
-      }
-    EOS
-
-    expect(@ap.send(:awesome, SomeModel)).to eq class_spec
-  end
-end
-
-# rubocop:enable Lint/ConstantDefinitionInBlock

data/spec/ext/nokogiri_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'AmazingPrint/Nokogiri' do
-  it 'colorizes tags' do
-    xml = Nokogiri::XML('<html><body><h1></h1></body></html>')
-    # FIXME: Due to something strange with Nokogiri and JRuby, we need to remove extra blank lines.
-    output = xml.ai.gsub("\n\n", "\n")
-    expect(output).to eq <<~EOS
-      <?xml version="1.0"?>\e[1;32m
-      \e[0m<\e[1;36mhtml\e[0m>\e[1;32m
-        \e[0m<\e[1;36mbody\e[0m>\e[1;32m
-          \e[0m<\e[1;36mh1\e[0m/>\e[1;32m
-        \e[0m<\e[1;36m/body\e[0m>\e[1;32m
-      \e[0m<\e[1;36m/html\e[0m>
-    EOS
-  end
-
-  it 'colorizes contents' do
-    xml = Nokogiri::XML('<html><body><h1>Hello</h1></body></html>')
-    expect(xml.ai).to eq <<~EOS
-      <?xml version="1.0"?>\e[1;32m
-      \e[0m<\e[1;36mhtml\e[0m>\e[1;32m
-        \e[0m<\e[1;36mbody\e[0m>\e[1;32m
-          \e[0m<\e[1;36mh1\e[0m>\e[1;32mHello\e[0m<\e[1;36m/h1\e[0m>\e[1;32m
-        \e[0m<\e[1;36m/body\e[0m>\e[1;32m
-      \e[0m<\e[1;36m/html\e[0m>
-    EOS
-  end
-
-  it 'colorizes class and id' do
-    xml = Nokogiri::XML('<html><body><h1><span class="world" id="hello"></span></h1></body></html>')
-    # FIXME: Due to something strange with Nokogiri and JRuby, we need to remove extra blank lines.
-    output = xml.ai.gsub("\n\n", "\n")
-    expect(output).to eq <<~EOS
-      <?xml version="1.0"?>\e[1;32m
-      \e[0m<\e[1;36mhtml\e[0m>\e[1;32m
-        \e[0m<\e[1;36mbody\e[0m>\e[1;32m
-          \e[0m<\e[1;36mh1\e[0m>\e[1;32m
-            \e[0m<\e[1;36mspan\e[0m \e[1;33mclass="world"\e[0m \e[1;33mid="hello"\e[0m/>\e[1;32m
-          \e[0m<\e[1;36m/h1\e[0m>\e[1;32m
-        \e[0m<\e[1;36m/body\e[0m>\e[1;32m
-      \e[0m<\e[1;36m/html\e[0m>
-    EOS
-  end
-
-  it 'handle empty NodeSet' do
-    xml = Nokogiri::XML::NodeSet.new(Nokogiri::XML(''))
-    expect(xml.ai).to eq('[]')
-  end
-end

data/spec/ext/ostruct_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'AmazingPrint Ostruct extension' do
-  before do
-    @ap = AmazingPrint::Inspector.new(plain: true, sort_keys: true)
-  end
-
-  it 'empty hash' do
-    struct = OpenStruct.new
-    expect(@ap.send(:awesome, struct)).to eq('OpenStruct {}')
-  end
-
-  it 'plain multiline' do
-    struct = OpenStruct.new name: 'Foo', address: 'Bar'
-    expect(@ap.send(:awesome, struct)).to eq <<~EOS.strip
-      OpenStruct {
-          :address => "Bar",
-             :name => "Foo"
-      }
-    EOS
-  end
-end

data/spec/ext/ripple_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Lint/ConstantDefinitionInBlock
-
-require 'spec_helper'
-
-RSpec.describe 'AmazingPrint/Ripple', skip: -> { !ExtVerifier.has_ripple? }.call do
-  if ExtVerifier.has_ripple?
-    before :all do
-      class RippleUser
-        include Ripple::Document
-
-        key_on :_id
-        property :_id, String
-        property :first_name, String
-        property :last_name,  String
-      end
-    end
-
-    after :all do
-      Object.instance_eval { remove_const :RippleUser }
-    end
-  end
-
-  before do
-    @ap = AmazingPrint::Inspector.new plain: true, sort_keys: true
-  end
-
-  it 'prints class instance' do
-    user = RippleUser.new _id: '12345', first_name: 'Al', last_name: 'Capone'
-    out = @ap.send :awesome, user
-
-    expect(out).to be_similar_to <<~EOS.strip
-      #<RippleUser:placeholder_id> {
-                 :_id => "12345",
-          :first_name => "Al",
-           :last_name => "Capone"
-      }
-    EOS
-  end
-
-  it 'prints the class' do
-    expect(@ap.send(:awesome, RippleUser)).to eq <<~EOS.strip
-      class RippleUser < Object {
-                 :_id => :string,
-          :first_name => :string,
-           :last_name => :string
-      }
-    EOS
-  end
-end
-
-# rubocop:enable Lint/ConstantDefinitionInBlock

data/spec/ext/sequel_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'sequel_helper'
-
-RSpec.describe 'AmazingPrint/Sequel', skip: -> { !ExtVerifier.has_sequel? }.call do
-  before do
-    @ap = AmazingPrint::Inspector.new plain: true, sort_keys: true
-    @user1 = SequelUser.new first_name: 'Jeremy', last_name: 'Evans'
-    @user2 = SequelUser.new first_name: 'Sequel', last_name: 'Five'
-  end
-
-  it 'display single record' do
-    out = @ap.awesome(@user1)
-    str = <<~EOS.strip
-      #<SequelUser:placeholder_id> {
-          :first_name => "Jeremy",
-           :last_name => "Evans"
-      }
-    EOS
-    expect(out).to be_similar_to(str)
-  end
-
-  it 'display multiple records' do
-    out = @ap.awesome([@user1, @user2])
-    str = <<~EOS.strip
-      [
-          [0] #<SequelUser:placeholder_id> {
-              :first_name => "Jeremy",
-               :last_name => "Evans"
-          },
-          [1] #<SequelUser:placeholder_id> {
-              :first_name => "Sequel",
-               :last_name => "Five"
-          }
-      ]
-    EOS
-    expect(out).to be_similar_to(str)
-  end
-
-  it 'does not crash if on Sequel::Model' do
-    out = @ap.awesome(Sequel::Model)
-    expect(out).to be_similar_to('Sequel::Model < Object')
-  end
-end