engineyard-serverside 2.8.0.pre4 → 3.0.4

data/lib/vendor/multi_json/lib/multi_json.rb

@@ -1,137 +0,0 @@
-module MultiJson
-  extend self
-
-  class LoadError < StandardError
-    attr_reader :data
-    def initialize(message='', backtrace=[], data='')
-      super(message)
-      self.set_backtrace(backtrace)
-      @data = data
-    end
-  end
-  DecodeError = LoadError # Legacy support
-
-
-  @default_options = {}
-  attr_accessor :default_options
-
-  REQUIREMENT_MAP = [
-    ['oj',        :oj],
-    ['yajl',      :yajl],
-    ['json',      :json_gem],
-    ['gson',      :gson],
-    ['json/pure', :json_pure]
-  ]
-
-  # The default adapter based on what you currently
-  # have loaded and installed. First checks to see
-  # if any adapters are already loaded, then checks
-  # to see which are installed if none are loaded.
-  def default_adapter
-    return :oj if defined?(::Oj)
-    return :yajl if defined?(::Yajl)
-    return :json_gem if defined?(::JSON)
-    return :gson if defined?(::Gson)
-
-    REQUIREMENT_MAP.each do |(library, adapter)|
-      begin
-        require library
-        return adapter
-      rescue ::LoadError
-        next
-      end
-    end
-
-    Kernel.warn '[WARNING] MultiJson is using the default adapter (ok_json). We recommend loading a different JSON library to improve performance.'
-    :ok_json
-  end
-  # :nodoc:
-  alias :default_engine :default_adapter
-
-  # Get the current adapter class.
-  def adapter
-    return @adapter if defined?(@adapter) && @adapter
-
-    self.use nil # load default adapter
-
-    @adapter
-  end
-  # :nodoc:
-  alias :engine :adapter
-
-  # Set the JSON parser utilizing a symbol, string, or class.
-  # Supported by default are:
-  #
-  # * <tt>:oj</tt>
-  # * <tt>:json_gem</tt>
-  # * <tt>:json_pure</tt>
-  # * <tt>:ok_json</tt>
-  # * <tt>:yajl</tt>
-  # * <tt>:nsjsonserialization</tt> (MacRuby only)
-  # * <tt>:gson</tt> (JRuby only)
-  def use(new_adapter)
-    @adapter = load_adapter(new_adapter)
-  end
-  alias :adapter= :use
-  # :nodoc:
-  alias :engine= :use
-
-  def load_adapter(new_adapter)
-    case new_adapter
-    when String, Symbol
-      require "multi_json/adapters/#{new_adapter}"
-      MultiJson::Adapters.const_get(:"#{new_adapter.to_s.split('_').map{|s| s.capitalize}.join('')}")
-    when NilClass, FalseClass
-      load_adapter default_adapter
-    when Class, Module
-      new_adapter
-    else
-      raise "Did not recognize your adapter specification. Please specify either a symbol or a class."
-    end
-  end
-
-  # Decode a JSON string into Ruby.
-  #
-  # <b>Options</b>
-  #
-  # <tt>:symbolize_keys</tt> :: If true, will use symbols instead of strings for the keys.
-  # <tt>:adapter</tt> :: If set, the selected engine will be used just for the call.
-  def load(string, options={})
-    adapter = current_adapter(options)
-    begin
-      adapter.load(string, options)
-    rescue adapter::ParseError => exception
-      raise LoadError.new(exception.message, exception.backtrace, string)
-    end
-  end
-  # :nodoc:
-  alias :decode :load
-
-  def current_adapter(options)
-    if new_adapter = (options || {}).delete(:adapter)
-      load_adapter(new_adapter)
-    else
-      adapter
-    end
-  end
-
-  # Encodes a Ruby object as JSON.
-  def dump(object, options={})
-    options = default_options.merge(options)
-    adapter = current_adapter(options)
-    adapter.dump(object, options)
-  end
-  # :nodoc:
-  alias :encode :dump
-
-  #  Executes passed block using specified adapter.
-  def with_adapter(new_adapter)
-    old_adapter, self.adapter = adapter, new_adapter
-    yield
-  ensure
-    self.adapter = old_adapter
-  end
-  # :nodoc:
-  alias :with_engine :with_adapter
-
-end

data/lib/vendor/multi_json/spec/adapter_shared_example.rb

@@ -1,162 +0,0 @@
-# encoding: UTF-8
-
-shared_examples_for 'an adapter' do |adapter|
-
-  before do
-    begin
-      MultiJson.use adapter
-    rescue LoadError
-      pending "Adapter #{adapter} couldn't be loaded (not installed?)"
-    end
-  end
-
-  describe '.dump' do
-    it 'writes decodable JSON' do
-      [
-        {'abc' => 'def'},
-        [1, 2, 3, '4', true, false, nil]
-      ].each do |example|
-        expect(MultiJson.load(MultiJson.dump(example))).to eq example
-      end
-    end
-
-    unless 'json_pure' == adapter || 'json_gem' == adapter
-      it 'dumps time in correct format' do
-        time = Time.at(1355218745).utc
-
-        # time does not respond to to_json method
-        class << time
-          undef_method :to_json
-        end
-
-        dumped_json = MultiJson.dump(time)
-        expected = if RUBY_VERSION > '1.9'
-          '2012-12-11 09:39:05 UTC'
-        else
-          'Tue Dec 11 09:39:05 UTC 2012'
-        end
-        expect(MultiJson.load(dumped_json)).to eq expected
-      end
-    end
-
-    it 'dumps symbol and fixnum keys as strings' do
-      [
-        [
-          {:foo => {:bar => 'baz'}},
-          {'foo' => {'bar' => 'baz'}},
-        ],
-        [
-          [{:foo => {:bar => 'baz'}}],
-          [{'foo' => {'bar' => 'baz'}}],
-        ],
-        [
-          {:foo => [{:bar => 'baz'}]},
-          {'foo' => [{'bar' => 'baz'}]},
-        ],
-        [
-          {1 => {2 => {3 => 'bar'}}},
-          {'1' => {'2' => {'3' => 'bar'}}}
-        ]
-      ].each do |example, expected|
-        dumped_json = MultiJson.dump(example)
-        expect(MultiJson.load(dumped_json)).to eq expected
-      end
-    end
-
-    it 'dumps rootless JSON' do
-      expect(MultiJson.dump('random rootless string')).to eq '"random rootless string"'
-      expect(MultiJson.dump(123)).to eq '123'
-    end
-
-    it 'passes options to the adapter' do
-      MultiJson.adapter.should_receive(:dump).with('foo', {:bar => :baz})
-      MultiJson.dump('foo', :bar => :baz)
-    end
-
-    # This behavior is currently not supported by gson.rb
-    # See discussion at https://github.com/intridea/multi_json/pull/71
-    unless adapter == 'gson'
-      it 'dumps custom objects that implement to_json' do
-        klass = Class.new do
-          def to_json(*)
-            '"foobar"'
-          end
-        end
-        expect(MultiJson.dump(klass.new)).to eq '"foobar"'
-      end
-    end
-
-    it 'allows to dump JSON values' do
-      expect(MultiJson.dump(42)).to eq '42'
-    end
-
-    it 'allows to dump JSON with UTF-8 characters' do
-      expect(MultiJson.dump({'color' => 'żółć'})).to eq('{"color":"żółć"}')
-    end
-  end
-
-  describe '.load' do
-    it 'properly loads valid JSON' do
-      expect(MultiJson.load('{"abc":"def"}')).to eq({'abc' => 'def'})
-    end
-
-    it 'raises MultiJson::LoadError on invalid JSON' do
-      expect{MultiJson.load('{"abc"}')}.to raise_error(MultiJson::LoadError)
-    end
-
-    it 'raises MultiJson::LoadError with data on invalid JSON' do
-      data = '{invalid}'
-      begin
-        MultiJson.load(data)
-      rescue MultiJson::LoadError => le
-        expect(le.data).to eq data
-      end
-    end
-
-    it 'catches MultiJson::DecodeError for legacy support' do
-      data = '{invalid}'
-      begin
-        MultiJson.load(data)
-      rescue MultiJson::DecodeError => de
-        expect(de.data).to eq data
-      end
-    end
-
-    it 'stringifys symbol keys when encoding' do
-      dumped_json = MultiJson.dump(:a => 1, :b => {:c => 2})
-      expect(MultiJson.load(dumped_json)).to eq({'a' => 1, 'b' => {'c' => 2}})
-    end
-
-    it 'properly loads valid JSON in StringIOs' do
-      json = StringIO.new('{"abc":"def"}')
-      expect(MultiJson.load(json)).to eq({'abc' => 'def'})
-    end
-
-    it 'allows for symbolization of keys' do
-      [
-        [
-          '{"abc":{"def":"hgi"}}',
-          {:abc => {:def => 'hgi'}},
-        ],
-        [
-          '[{"abc":{"def":"hgi"}}]',
-          [{:abc => {:def => 'hgi'}}],
-        ],
-        [
-          '{"abc":[{"def":"hgi"}]}',
-          {:abc => [{:def => 'hgi'}]},
-        ],
-      ].each do |example, expected|
-        expect(MultiJson.load(example, :symbolize_keys => true)).to eq expected
-      end
-    end
-
-    it 'allows to load JSON values' do
-      expect(MultiJson.load('42')).to eq 42
-    end
-
-    it 'allows to load JSON with UTF-8 characters' do
-      expect(MultiJson.load('{"color":"żółć"}')).to eq({'color' => 'żółć'})
-    end
-  end
-end

data/lib/vendor/multi_json/spec/helper.rb

@@ -1,45 +0,0 @@
-if !ENV['CI'] && defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter 'vendor'
-  end
-end
-
-require 'multi_json'
-require 'rspec'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end
-
-def macruby?
-  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'macruby'
-end
-
-def jruby?
-  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-end
-
-class MockDecoder
-  def self.load(string, options={})
-    {'abc' => 'def'}
-  end
-
-  def self.dump(string)
-    '{"abc":"def"}'
-  end
-end
-
-module MockModuleDecoder
-  extend self
-
-  def load(string, options={})
-    {'abc' => 'def'}
-  end
-
-  def dump(string)
-    '{"abc":"def"}'
-  end
-end

data/lib/vendor/multi_json/spec/json_common_shared_example.rb

@@ -1,36 +0,0 @@
-shared_examples_for 'JSON-like adapter' do |adapter|
-  before do
-    begin
-      MultiJson.use adapter
-    rescue LoadError
-      pending "Adapter #{adapter} couldn't be loaded (not installed?)"
-    end
-  end
-
-  describe '.dump' do
-    describe 'with :pretty option set to true' do
-      it 'passes default pretty options' do
-        object = 'foo'
-        object.should_receive(:to_json).with(JSON::PRETTY_STATE_PROTOTYPE.to_h).and_return('["foo"]')
-        MultiJson.dump(object, :pretty => true)
-      end
-    end
-
-    describe 'with :indent option' do
-      it 'passes it on dump' do
-        object = 'foo'
-        object.should_receive(:to_json).with(:indent => "\t").and_return('["foo"]')
-        MultiJson.dump(object, :indent => "\t")
-      end
-    end
-  end
-
-  describe '.load' do
-    describe 'with :quirks_mode option' do
-      it 'passes it on load' do
-        ::JSON.should_receive(:parse).with('["foo"]', {:quirks_mode => true, :create_additions => false}).and_return(['foo'])
-        MultiJson.load('"foo"', :quirks_mode => true)
-      end
-    end
-  end
-end

data/lib/vendor/multi_json/spec/multi_json_spec.rb

@@ -1,151 +0,0 @@
-require 'helper'
-require 'adapter_shared_example'
-require 'json_common_shared_example'
-require 'stringio'
-
-describe 'MultiJson' do
-  context 'adapters' do
-    before{ MultiJson.use nil }
-
-    context 'when no other json implementations are available' do
-      before do
-        @old_map = MultiJson::REQUIREMENT_MAP
-        @old_json = Object.const_get :JSON if Object.const_defined?(:JSON)
-        @old_oj = Object.const_get :Oj if Object.const_defined?(:Oj)
-        @old_yajl = Object.const_get :Yajl if Object.const_defined?(:Yajl)
-        @old_gson = Object.const_get :Gson if Object.const_defined?(:Gson)
-        MultiJson::REQUIREMENT_MAP.each_with_index do |(library, adapter), index|
-          MultiJson::REQUIREMENT_MAP[index] = ["foo/#{library}", adapter]
-        end
-        Object.send :remove_const, :JSON if @old_json
-        Object.send :remove_const, :Oj if @old_oj
-        Object.send :remove_const, :Yajl if @old_yajl
-        Object.send :remove_const, :Gson if @old_gson
-      end
-
-      after do
-        @old_map.each_with_index do |(library, adapter), index|
-          MultiJson::REQUIREMENT_MAP[index] = [library, adapter]
-        end
-        Object.const_set :JSON, @old_json if @old_json
-        Object.const_set :Oj, @old_oj if @old_oj
-        Object.const_set :Yajl, @old_yajl if @old_yajl
-        Object.const_set :Gson, @old_gson if @old_gson
-      end
-
-      it 'defaults to ok_json if no other json implementions are available' do
-        Kernel.stub(:warn)
-        expect(MultiJson.default_adapter).to eq :ok_json
-      end
-
-      it 'prints a warning' do
-        Kernel.should_receive(:warn).with(/warning/i)
-        MultiJson.default_adapter
-      end
-    end
-
-    it 'defaults to the best available gem' do
-      # Clear cache variable already set by previous tests
-      MultiJson.send(:remove_instance_variable, :@adapter)
-      unless jruby?
-        require 'oj'
-        expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::Oj'
-      else
-        require 'json'
-        expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonGem'
-      end
-    end
-
-    it 'looks for adapter even if @adapter variable is nil' do
-      MultiJson.send(:instance_variable_set, :@adapter, nil)
-      MultiJson.should_receive(:default_adapter).and_return(:ok_json)
-      expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::OkJson'
-    end
-
-    it 'is settable via a symbol' do
-      MultiJson.use :json_gem
-      expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonGem'
-    end
-
-    it 'is settable via a class' do
-      MultiJson.use MockDecoder
-      expect(MultiJson.adapter.name).to eq 'MockDecoder'
-    end
-
-    it 'is settable via a module' do
-      MultiJson.use MockModuleDecoder
-      expect(MultiJson.adapter.name).to eq 'MockModuleDecoder'
-    end
-
-    context 'using one-shot parser' do
-      before do
-        require 'multi_json/adapters/json_pure'
-        MultiJson::Adapters::JsonPure.should_receive(:dump).exactly(1).times.and_return('dump_something')
-        MultiJson::Adapters::JsonPure.should_receive(:load).exactly(1).times.and_return('load_something')
-      end
-
-      it 'should use the defined parser just for the call' do
-        MultiJson.use :json_gem
-        expect(MultiJson.dump('', :adapter => :json_pure)).to eq 'dump_something'
-        expect(MultiJson.load('', :adapter => :json_pure)).to eq 'load_something'
-        expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonGem'
-      end
-    end
-  end
-
-  it 'can set adapter for a block' do
-    MultiJson.use :ok_json
-    MultiJson.with_adapter(:json_pure) do
-      MultiJson.with_engine(:json_gem) do
-        expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonGem'
-      end
-      expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonPure'
-    end
-    expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::OkJson'
-  end
-
-  it 'JSON gem does not create symbols on parse' do
-    MultiJson.with_engine(:json_gem) do
-      MultiJson.load('{"json_class":"ZOMG"}') rescue nil
-
-      expect{
-        MultiJson.load('{"json_class":"OMG"}') rescue nil
-      }.to_not change{Symbol.all_symbols.count}
-    end
-  end
-
-  unless jruby?
-    it 'Oj does not create symbols on parse' do
-      MultiJson.with_engine(:oj) do
-        MultiJson.load('{"json_class":"ZOMG"}') rescue nil
-
-        expect{
-          MultiJson.load('{"json_class":"OMG"}') rescue nil
-        }.to_not change{Symbol.all_symbols.count}
-      end
-    end
-  end
-
-  it 'has default_options setter' do
-    MultiJson.use MockDecoder
-    MockDecoder.should_receive(:dump).with('123', :foo => 'lol', :bar => 'bar', :fizz => 'buzz')
-    MultiJson.default_options = { :foo => 'foo', :bar => 'bar' }
-    MultiJson.dump('123', :fizz => 'buzz', :foo => 'lol')
-    MultiJson.default_options = {}
-  end
-
-  %w(gson json_gem json_pure nsjsonserialization oj ok_json yajl).each do |adapter|
-    next if adapter == 'gson' && !jruby?
-    next if adapter == 'nsjsonserialization' && !macruby?
-    next if jruby? && (adapter == 'oj' || adapter == 'yajl')
-    context adapter do
-      it_behaves_like 'an adapter', adapter
-    end
-  end
-
-  %w(json_gem json_pure).each do |adapter|
-    context adapter do
-      it_behaves_like 'JSON-like adapter', adapter
-    end
-  end
-end

data/spec/archive_deploy_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-class EY::Serverside::Source::Archive
-  def fetch_command
-    "cp #{uri} #{source_cache}"
-  end
-end
-
-describe "Deploying a simple application" do
-
-  before(:all) do
-    adapter = EY::Serverside::Adapter.new do |args|
-      args.account_name = "account"
-      args.app = "application_name"
-      args.stack = "nginx_unicorn"
-      args.environment_name = "environment_name"
-      args.framework_env = "production"
-      args.archive = FIXTURES_DIR.join('retwisj.war')
-      args.verbose = true
-      args.instances = [{ :hostname => "localhost", :roles => ["solo"], :name => "single" }]
-      args.serverside_version = Gem::Version.create(EY::Serverside::VERSION.dup).release
-      args.config = {
-        "deploy_to" => deploy_dir.to_s,
-        "group"            => GROUP
-      }
-    end
-    argv = adapter.deploy.commands.last.to_argv[2..-1]
-    with_mocked_commands do
-      capture do
-        EY::Serverside::CLI::App.start(argv)
-      end
-    end
-  end
-
-  it "exploded the war" do
-    %w(META-INF WEB-INF).each {|dir|
-      File.exists?(deploy_dir.join('current', dir))
-    }
-  end
-
-  it "creates a REVISION file" do
-    path = deploy_dir.join('current', 'REVISION')
-    expect(path).to exist
-    checksum = File.read(path).strip
-    expect(checksum).to match(/7400dc058376745c11a98f768b799c6651428857\s+.*retwisj.war$/)
-  end
-
-  it "restarts the app servers" do
-    restart = deploy_dir.join('current', 'restart')
-    expect(restart).to exist
-    expect(restart.read.chomp).to eq(%|LANG="en_US.UTF-8" /engineyard/bin/app_application_name deploy|)
-  end
-end

data/spec/basic_deploy_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe "Deploying a simple application" do
-  before(:all) do
-    deploy_test_application('not_bundled')
-  end
-
-  it "creates a REVISION file" do
-    expect(deploy_dir.join('current', 'REVISION')).to exist
-  end
-
-  it "restarts the app servers" do
-    restart = deploy_dir.join('current', 'restart')
-    expect(restart).to exist
-    expect(restart.read.chomp).to eq(%|LANG="en_US.UTF-8" /engineyard/bin/app_rails31 deploy|)
-  end
-
-  it "reuses the same active_release directory if a release_path is specified (such as in integrate)" do
-    path = @config.paths.active_release
-    expect(path.parent.children.size).to eq(1)
-
-    redeploy_test_application('config' => {'release_path' => path.to_s})
-
-    expect(path.parent.children.size).to eq(1)
-  end
-end