gon 6.3.2 → 6.5.0

data/spec/gon/basic_spec.rb

@@ -1,304 +0,0 @@
-describe Gon do
-
-  before(:each) do
-    Gon.clear
-  end
-
-  describe '#all_variables' do
-
-    it 'returns all variables in hash' do
-      Gon.a = 1
-      Gon.b = 2
-      Gon.c = Gon.a + Gon.b
-      expect(Gon.c).to eq(3)
-      expect(Gon.all_variables).to eq({ 'a' => 1, 'b' => 2, 'c' => 3 })
-    end
-
-    it 'supports all data types' do
-      Gon.int          = 1
-      Gon.float        = 1.1
-      Gon.string       = 'string'
-      Gon.symbol       = :symbol
-      Gon.array        = [1, 'string']
-      Gon.hash_var     = { :a => 1, :b => '2' }
-      Gon.hash_w_array = { :a => [2, 3] }
-      Gon.klass        = Hash
-    end
-
-    it 'can be filled with dynamic named variables' do
-      check = {}
-      3.times do |i|
-        Gon.set_variable("variable#{i}", i)
-        check["variable#{i}"] = i
-      end
-
-      expect(Gon.all_variables).to eq(check)
-    end
-
-    it 'can set and get variable with dynamic name' do
-      var_name = "variable#{rand}"
-
-      Gon.set_variable(var_name, 1)
-      expect(Gon.get_variable(var_name)).to eq(1)
-    end
-
-    it 'can be support new push syntax' do
-      Gon.push({ :int => 1, :string => 'string' })
-      expect(Gon.all_variables).to eq({ 'int' => 1, 'string' => 'string' })
-    end
-
-    it 'push with wrong object' do
-      expect {
-        Gon.push(String.new('string object'))
-      }.to raise_error('Object must have each_pair method')
-    end
-
-    describe "#merge_variable" do
-      it 'deep merges the same key' do
-        Gon.merge_variable(:foo, { bar: { tar: 12 }, car: 23 })
-        Gon.merge_variable(:foo, { bar: { dar: 21 }, car: 12 })
-        expect(Gon.get_variable(:foo)).to  eq(bar: { tar: 12, dar: 21 }, car: 12)
-      end
-
-      it 'merges on push with a flag' do
-        Gon.push(foo: { bar: 1 })
-        Gon.push({ foo: { tar: 1 } }, :merge)
-        expect(Gon.get_variable("foo")).to eq(bar: 1, tar: 1)
-      end
-
-      context 'overrides key' do
-        specify "the previous value wasn't hash" do
-          Gon.merge_variable(:foo, 2)
-          Gon.merge_variable(:foo, { a: 1 })
-          expect(Gon.get_variable(:foo)).to eq(a: 1)
-        end
-
-        specify "the new value isn't a hash" do
-          Gon.merge_variable(:foo, { a: 1 })
-          Gon.merge_variable(:foo, 2)
-          expect(Gon.get_variable(:foo)).to eq(2)
-        end
-      end
-    end
-
-  end
-
-  describe '#include_gon' do
-
-    before(:each) do
-      Gon::Request.
-        instance_variable_set(:@request_id, request.object_id)
-      expect(ActionView::Base.instance_methods).to include(:include_gon)
-      @base = ActionView::Base.new
-      @base.request = request
-    end
-
-    it 'outputs correct js with an integer' do
-      Gon.int = 1
-      expect(@base.include_gon).to eq(wrap_script(
-                                'window.gon={};' +
-                                'gon.int=1;'))
-    end
-
-    it 'outputs correct js with a string' do
-      Gon.str = %q(a'b"c)
-      expect(@base.include_gon).to eq(wrap_script(
-                                'window.gon={};' +
-                                %q(gon.str="a'b\"c";))
-      )
-    end
-
-    it 'outputs correct js with a script string' do
-      Gon.str = %q(</script><script>alert('!')</script>)
-      escaped_str = "\\u003c/script\\u003e\\u003cscript\\u003ealert('!')\\u003c/script\\u003e"
-      expect(@base.include_gon).to eq(wrap_script(
-                                'window.gon={};' +
-                                %Q(gon.str="#{escaped_str}";))
-      )
-    end
-
-    it 'outputs correct js with an integer and type' do
-      Gon.int = 1
-      expect(@base.include_gon(type: true)).to eq('<script type="text/javascript">' +
-                                    "\n//<![CDATA[\n" +
-                                    'window.gon={};' +
-                                    'gon.int=1;' +
-                                    "\n//]]>\n" +
-                                  '</script>')
-    end
-
-    it 'outputs correct js with an integer, camel-case and namespace' do
-      Gon.int_cased = 1
-      expect(@base.include_gon(camel_case: true, namespace: 'camel_cased')).to eq(
-                                  wrap_script('window.camel_cased={};' +
-                                    'camel_cased.intCased=1;')
-      )
-    end
-
-    it 'outputs correct js with camel_depth = :recursive' do
-      Gon.test_hash = { test_depth_one: { test_depth_two: 1 } }
-      expect(@base.include_gon(camel_case: true, camel_depth: :recursive)).to eq(
-                                  wrap_script('window.gon={};' +
-                                    'gon.testHash={"testDepthOne":{"testDepthTwo":1}};')
-      )
-    end
-
-    it 'outputs correct js with camel_depth = 2' do
-      Gon.test_hash = { test_depth_one: { test_depth_two: 1 } }
-      expect(@base.include_gon(camel_case: true, camel_depth: 2)).to eq(
-                                  wrap_script('window.gon={};' +
-                                    'gon.testHash={"testDepthOne":{"test_depth_two":1}};')
-      )
-    end
-
-    it 'outputs correct js for an array with camel_depth = :recursive' do
-      Gon.test_hash = { test_depth_one: [{ test_depth_two: 1 }, { test_depth_two: 2 }] }
-      expect(@base.include_gon(camel_case: true, camel_depth: :recursive)).to eq( \
-                                  wrap_script('window.gon={};' +
-                                    'gon.testHash={"testDepthOne":[{"testDepthTwo":1},{"testDepthTwo":2}]};')
-      )
-    end
-
-    it 'outputs correct key with camel_case option set alternately ' do
-      Gon.test_hash = 1
-      @base.include_gon(camel_case: true)
-
-      expect(@base.include_gon(camel_case: false)).to eq(
-                                 wrap_script('window.gon={};' +
-                                   'gon.test_hash=1;')
-      )
-    end
-
-    it 'outputs correct js with an integer and without tag' do
-      Gon.int = 1
-      expect(@base.include_gon(need_tag: false)).to eq( \
-                                  'window.gon={};' +
-                                  'gon.int=1;'
-      )
-    end
-
-    it 'outputs correct js without variables, without tag and gon init if before there was data' do
-      Gon::Request.
-        instance_variable_set(:@request_id, 123)
-      Gon::Request.instance_variable_set(:@request_env, { 'gon' => { :a => 1 } })
-      expect(@base.include_gon(need_tag: false, init: true)).to eq( \
-                                  'window.gon={};'
-      )
-    end
-
-    it 'outputs correct js without variables, without tag and gon init' do
-      expect(@base.include_gon(need_tag: false, init: true)).to eq( \
-                                  'window.gon={};'
-      )
-    end
-
-    it 'outputs correct js without variables, without tag, gon init and an integer' do
-      Gon.int = 1
-      expect(@base.include_gon(need_tag: false, init: true)).to eq( \
-                                  'window.gon={};' +
-                                  'gon.int=1;'
-      )
-    end
-
-    it 'outputs correct js without cdata, without type, gon init and an integer' do
-      Gon.int = 1
-      expect(@base.include_gon(cdata: false, type: false)).to eq(
-                                  wrap_script(
-                                    "\n" +
-                                    'window.gon={};' +
-                                    'gon.int=1;' +
-                                    "\n", false)
-      )
-    end
-
-    it 'outputs correct js with type text/javascript' do
-      expect(@base.include_gon(need_type: true, init: true)).to eq(wrap_script('window.gon={};'))
-    end
-
-    it 'outputs correct js with namespace check' do
-      expect(@base.include_gon(namespace_check: true)).to eq(wrap_script('window.gon=window.gon||{};'))
-    end
-
-    it 'outputs correct js without namespace check' do
-      expect(@base.include_gon(namespace_check: false)).to eq(wrap_script('window.gon={};'))
-    end
-
-    context "without a current_gon instance" do
-
-      before(:each) do
-        RequestStore.store[:gon] = nil
-        allow(Gon).to receive(:current_gon).and_return(nil)
-      end
-
-      it "does not raise an exception" do
-        expect { @base.include_gon }.to_not raise_error
-      end
-
-      it 'outputs correct js' do
-        expect(@base.include_gon).to eq("")
-      end
-
-      it 'outputs correct js with init' do
-        expect(@base.include_gon(init: true)).to eq(wrap_script('window.gon={};'))
-      end
-
-    end
-
-  end
-
-  describe '#include_gon_amd' do
-
-    before(:each) do
-      Gon::Request.
-        instance_variable_set(:@request_id, request.object_id)
-      @base = ActionView::Base.new
-      @base.request = request
-    end
-
-    it 'is included in ActionView::Base as a helper' do
-      expect(ActionView::Base.instance_methods).to include(:include_gon_amd)
-    end
-
-    it 'outputs correct js without variables' do
-      expect(@base.include_gon_amd).to eq( wrap_script( \
-                                    'define(\'gon\',[],function(){'+
-                                    'var gon={};return gon;'+
-                                    '});')
-      )
-    end
-
-    it 'outputs correct js with an integer' do
-      Gon.int = 1
-
-      expect(@base.include_gon_amd).to eq( wrap_script(
-                                    'define(\'gon\',[],function(){'+
-                                    'var gon={};gon[\'int\']=1;return gon;'+
-                                    '});')
-      )
-    end
-
-    it 'outputs correct module name when given a namespace' do
-      expect(@base.include_gon_amd(namespace: 'data')).to eq(wrap_script(
-                                    'define(\'data\',[],function(){'+
-                                    'var gon={};return gon;'+
-                                    '});')
-      )
-    end
-  end
-
-  it 'returns exception if try to set public method as variable' do
-    expect { Gon.all_variables = 123 }.to raise_error(RuntimeError)
-    expect { Gon.rabl = 123 }.to raise_error(RuntimeError)
-  end
-
-  describe '#check_for_rabl_and_jbuilder' do
-
-    let(:controller) { ActionController::Base.new }
-
-    it 'should be able to handle constants array (symbols)' do
-      allow(Gon).to receive(:constants) { Gon.constants }
-      expect { Gon.rabl :template => 'spec/test_data/sample.rabl', :controller => controller }.not_to raise_error
-      expect { Gon.jbuilder :template => 'spec/test_data/sample.json.jbuilder', :controller => controller }.not_to raise_error
-    end
-  end
-end

data/spec/gon/global_spec.rb

@@ -1,146 +0,0 @@
-describe Gon::Global do
-
-  before(:each) do
-    Gon::Global.clear
-    Gon::Request.instance_variable_set(:@request_env, nil)
-  end
-
-  describe '#all_variables' do
-
-    it 'returns all variables in hash' do
-      Gon.global.a = 1
-      Gon.global.b = 2
-      Gon.global.c = Gon.global.a + Gon.global.b
-      expect(Gon.global.c).to eq(3)
-      expect(Gon.global.all_variables).to eq({ 'a' => 1, 'b' => 2, 'c' => 3 })
-    end
-
-    it 'supports all data types' do
-      Gon.global.int          = 1
-      Gon.global.float        = 1.1
-      Gon.global.string       = 'string'
-      Gon.global.symbol       = :symbol
-      Gon.global.array        = [1, 'string']
-      Gon.global.hash_var     = { :a => 1, :b => '2' }
-      Gon.global.hash_w_array = { :a => [2, 3] }
-      Gon.global.klass        = Hash
-    end
-
-  end
-
-  describe '#include_gon' do
-
-    before(:each) do
-      Gon.clear
-      expect(ActionView::Base.instance_methods).to include(:include_gon)
-      @base = ActionView::Base.new
-      @base.request = request
-    end
-
-    it 'outputs correct js with an integer' do
-      Gon.global.int = 1
-      expect(@base.include_gon).to eq("<script>" +
-                                    "\n//<![CDATA[\n" +
-                                    "window.gon={};" +
-                                    "gon.global={\"int\":1};" +
-                                    "\n//]]>\n" +
-                                  "</script>")
-    end
-
-    it 'outputs correct js with an integer and integer in Gon' do
-      Gon.int = 1
-      Gon.global.int = 1
-      expect(@base.include_gon).to eq("<script>" +
-                                    "\n//<![CDATA[\n" +
-                                    "window.gon={};" +
-                                    "gon.global={\"int\":1};" +
-                                    "gon.int=1;" +
-                                    "\n//]]>\n" +
-                                  "</script>")
-    end
-
-    it 'outputs correct js with a string' do
-      Gon.global.str = %q(a'b"c)
-      expect(@base.include_gon).to eq("<script>" +
-                                    "\n//<![CDATA[\n" +
-                                    "window.gon={};" +
-                                    "gon.global={\"str\":\"a'b\\\"c\"};" +
-                                    "\n//]]>\n" +
-                                  "</script>")
-    end
-
-    it 'outputs correct js with a script string' do
-      Gon.global.str = %q(</script><script>alert('!')</script>)
-      escaped_str = "\\u003c/script\\u003e\\u003cscript\\u003ealert('!')\\u003c/script\\u003e"
-      expect(@base.include_gon).to eq("<script>" +
-                                    "\n//<![CDATA[\n" +
-                                    "window.gon={};" +
-                                    "gon.global={\"str\":\"#{escaped_str}\"};" +
-                                    "\n//]]>\n" +
-                                  "</script>")
-    end
-
-    it 'outputs correct js with a unicode line separator' do
-      Gon.global.str = "\u2028"
-      expect(@base.include_gon).to eq("<script>" +
-                                    "\n//<![CDATA[\n" +
-                                    "window.gon={};" +
-                                    "gon.global={\"str\":\"&#x2028;\"};" +
-                                    "\n//]]>\n" +
-                                  "</script>")
-    end
-
-    it 'outputs locally overridden value' do
-      Gon.str = 'local value'
-      Gon.global.str = 'global value'
-      expect(@base.include_gon(global_root: '')).to eq("<script>" +
-                                     "\n//<![CDATA[\n" +
-                                     "window.gon={};" +
-                                     "gon.str=\"local value\";" +
-                                     "\n//]]>\n" +
-                                     "</script>")
-    end
-
-    it "includes the tag attributes in the script tag" do
-      Gon.global.int = 1
-      expect(@base.include_gon(nonce: 'test')).to eq("<script nonce=\"test\">" +
-                                    "\n//<![CDATA[\n" +
-                                    "window.gon={};" +
-                                    "gon.global={\"int\":1};" +
-                                    "\n//]]>\n" +
-                                  "</script>")
-    end
-
-  end
-
-  it 'returns exception if try to set public method as variable' do
-    expect { Gon.global.all_variables = 123 }.to raise_error(RuntimeError)
-    expect { Gon.global.rabl = 123 }.to raise_error(RuntimeError)
-  end
-
-  context 'with jbuilder and rabl' do
-
-    before :each do
-      controller.instance_variable_set('@objects', objects)
-    end
-
-    let(:controller) { ActionController::Base.new }
-    let(:objects) { [1, 2] }
-
-    it 'works fine with rabl' do
-      Gon.global.rabl :template => 'spec/test_data/sample.rabl', :controller => controller
-      expect(Gon.global.objects.length).to eq(2)
-    end
-
-    it 'works fine with jbuilder' do
-      Gon.global.jbuilder :template => 'spec/test_data/sample.json.jbuilder', :controller => controller
-      expect(Gon.global.objects.length).to eq(2)
-    end
-
-    it 'should throw exception, if use rabl or jbuilder without :template' do
-      expect { Gon.global.rabl }.to raise_error(RuntimeError)
-      expect { Gon.global.jbuilder }.to raise_error(RuntimeError)
-    end
-
-  end
-end

data/spec/gon/jbuilder_spec.rb

@@ -1,75 +0,0 @@
-describe Gon do
-
-  describe '.jbuilder' do
-    context 'render jbuilder templates' do
-
-      before do
-        Gon.clear
-        controller.instance_variable_set('@objects', objects)
-      end
-
-      let(:controller) { ActionController::Base.new }
-      let(:objects) { [1, 2] }
-
-      it 'render json from jbuilder template' do
-        Gon.jbuilder :template => 'spec/test_data/sample.json.jbuilder', :controller => controller
-        expect(Gon.objects.length).to eq(2)
-      end
-
-      it 'render json from jbuilder template with locals' do
-        Gon.jbuilder :template => 'spec/test_data/sample_with_locals.json.jbuilder',
-                     :controller => controller,
-                     :locals => { :some_local => 1234, :some_complex_local => OpenStruct.new(:id => 1234) }
-        expect(Gon.some_local).to eq(1234)
-        expect(Gon.some_complex_local_id).to eq(1234)
-      end
-
-      it 'render json from jbuilder template with locals' do
-        Gon.jbuilder :template => 'spec/test_data/sample_with_helpers.json.jbuilder', :controller => controller
-        expect(Gon.date).to eq('about 6 hours')
-      end
-
-      it 'render json from jbuilder template with controller methods' do
-        class << controller
-          def private_controller_method
-            'gon test helper works'
-          end
-          helper_method :private_controller_method
-          private :private_controller_method
-        end
-
-        Gon.jbuilder :template => 'spec/test_data/sample_with_controller_method.json.jbuilder', :controller => controller
-        expect(Gon.data_from_method).to eq('gon test helper works')
-      end
-
-      it 'render json from jbuilder template with a partial' do
-        controller.view_paths << 'spec/test_data'
-        Gon.jbuilder :template => 'spec/test_data/sample_with_partial.json.jbuilder', :controller => controller
-        expect(Gon.objects.length).to eq(2)
-      end
-
-      context 'within Rails' do
-        before do
-          module ::Rails
-          end
-
-          allow(Rails).to receive_message_chain("application.routes.url_helpers.instance_methods") { [:user_path] }
-          controller.instance_variable_set('@user_id', 1)
-        end
-
-        after do
-          Object.send(:remove_const, :Rails)
-        end
-
-        it 'includes url_helpers' do
-          expect(controller).to receive(:user_path) { |id| "/users/#{id}" }
-          Gon.jbuilder :template => 'spec/test_data/sample_url_helpers.json.jbuilder', :controller => controller
-          expect(Gon.url).to eq '/users/1'
-        end
-      end
-
-    end
-
-  end
-
-end

data/spec/gon/rabl_spec.rb

@@ -1,90 +0,0 @@
-describe Gon do
-  describe '.rabl' do
-
-    before :each do
-      Gon.clear
-      controller.instance_variable_set('@objects', objects)
-    end
-
-    let(:controller) { ActionController::Base.new }
-    let(:objects) { [1, 2] }
-
-    context 'render template with deprecation' do
-      it 'still works' do
-        Gon.rabl 'spec/test_data/sample.rabl', :controller => controller
-        expect(Gon.objects.length).to eq(2)
-      end
-    end
-
-    context 'option locals' do
-      it 'works without locals object properly' do
-        Gon.rabl(
-          :template   => 'spec/test_data/sample.rabl',
-          :controller => controller
-        )
-        expect(Gon.objects.map { |it| it['object']['inspect'] }).to eq(%w(1 2))
-      end
-
-      it 'works with different locals object' do
-        Gon.rabl(
-          :template   => 'spec/test_data/sample.rabl',
-          :controller => controller,
-          :locals     => { :objects => [3, 4] }
-        )
-        expect(Gon.objects.map { |it| it['object']['inspect'] }).to eq(%w(3 4))
-      end
-    end
-
-    it 'works if rabl is included' do
-      Gon.rabl :template => 'spec/test_data/sample.rabl', :controller => controller
-      expect(Gon.objects.length).to eq(2)
-    end
-
-    it 'works with ActionView::Helpers' do
-      Gon.rabl :template => 'spec/test_data/sample_with_helpers.rabl', :controller => controller
-      expect(Gon.objects.first['object']['time_ago']).to eq('about 6 hours')
-    end
-
-    it 'raise exception if rabl is not included' do
-      Gon.send :remove_const, 'Rabl'
-      expect { Gon.rabl :template => 'spec/test_data/sample.rabl', :controller => controller }.to raise_error(NameError)
-      load 'rabl.rb'
-      load 'gon/rabl.rb'
-    end
-
-    context '.template_path' do
-      context 'template is specified' do
-
-        it 'add the extension if not included in the template name' do
-          expect(Gon::EnvFinder.send(:template_path, { :template => 'spec/test_data/sample' }, 'rabl')).to eql('spec/test_data/sample.rabl')
-        end
-
-        it 'return the specified template' do
-          expect(Gon::EnvFinder.send(:template_path, { :template => 'spec/test_data/sample.rabl' }, 'rabl')).to eql('spec/test_data/sample.rabl')
-        end
-
-      end
-
-      context 'template is not specified' do
-
-        before do
-          Gon.clear
-          controller.instance_variable_set('@objects', objects)
-          controller.action_name = 'show'
-        end
-
-        let(:controller) { ActionController::Base.new }
-        let(:objects) { [1, 2] }
-
-        context 'the action doesn as a template at a different format' do
-          it 'return the same template as the action with rabl extension' do
-            expect(Gon::EnvFinder.send(:template_path, { :controller => controller }, 'rabl')).to eql('app/views/action_controller/base/show.json.rabl')
-          end
-        end
-
-      end
-    end
-
-  end
-
-end

data/spec/gon/templates_spec.rb

@@ -1,36 +0,0 @@
-describe Gon do
-
-  describe '.template_path' do
-    context 'template is specified' do
-
-      it 'add the extension if not included in the template name' do
-        expect(Gon::EnvFinder.send(:template_path, { :template => 'spec/test_data/sample' }, 'jbuilder')).to eql('spec/test_data/sample.jbuilder')
-      end
-
-      it 'return the specified template' do
-        expect(Gon::EnvFinder.send(:template_path, { :template => 'spec/test_data/sample.jbuilder' }, 'jbuilder')).to eql('spec/test_data/sample.jbuilder')
-      end
-
-    end
-
-    context 'template is not specified' do
-
-      before do
-        Gon.clear
-        controller.instance_variable_set('@objects', objects)
-        controller.action_name = 'show'
-      end
-
-      let(:controller) { ActionController::Base.new }
-      let(:objects) { [1, 2] }
-
-      context 'the action doesn as a template at a different format' do
-        it 'return the same template as the action with rabl extension' do
-          expect(Gon::EnvFinder.send(:template_path, { :controller => controller }, 'jbuilder')).to eql('app/views/action_controller/base/show.json.jbuilder')
-        end
-      end
-
-    end
-  end
-
-end

data/spec/gon/thread_spec.rb

@@ -1,39 +0,0 @@
-class GonTestWorker
-  include Gon::ControllerHelpers
-
-  def request
-    @request ||= ActionDispatch::TestRequest.create
-  end
-
-  def env
-    request.env
-  end
-
-  def execute
-    gon.clear
-    gon.a ||= 1
-    gon.a += 1
-  end
-
-  def value
-    gon.a
-  end
-end
-
-describe 'threading behaviour' do
-  before do
-    allow(Gon).to receive(:current_gon).and_call_original
-  end
-
-  it 'is threadsafe' do
-    threads = []
-    10.times do
-      threads << Thread.new do
-        gtw = GonTestWorker.new
-        gtw.execute
-        expect(gtw.value).to eq 2
-      end
-    end
-    threads.each(&:join)
-  end
-end