gon 2.3.0 → 3.0.0

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# CHANGELOG
+
+## 3.0.0
+
+  * Almost all code refactored
+  * Added Gon.global for using gon everywhere
+  * Included ActionView::Helpers into Rabl::Engine
+
+## 2.3.0
+
+  * Don't really remember what was before this version

data/README.md

@@ -7,7 +7,7 @@
 
 If you need to send some data to your js files and you don't want to do this with long way through views and parsing - use this force!
 
-Now with [Jbuilder](https://github.com/rails/jbuilder) and [Rabl](https://github.com/nesquena/rabl) support!
+With [Jbuilder](https://github.com/rails/jbuilder) and [Rabl](https://github.com/nesquena/rabl) support!
 
 For Sinatra available [gon-sinatra](https://github.com/gazay/gon-sinatra).
 
@@ -129,7 +129,7 @@ alert(customNamespace.yourHash)
 
 ## Usage with Rabl
 
-Now you can write your variables assign logic to templates with [Rabl](https://github.com/nesquena/rabl).
+You can write your variables assign logic to templates with [Rabl](https://github.com/nesquena/rabl).
 The way of writing Rabl templates is very clearly described in their repo.
 
 Add Rabl to your Gemfile before requiring gon - because gon checks Rabl constant
@@ -265,7 +265,7 @@ Use gon with [Jbuilder](https://github.com/rails/jbuilder) as with [Rabl](https:
       # some controller logic
       @posts = Post.all
 
-      gon.jbuilder 'app/views/posts/index.json.jbuilder'
+      gon.jbuilder
       # some controller logic
     end
     ```
@@ -297,18 +297,42 @@ alert(gon.comments[0])
 P.s. If you didn't put include_gon tag in your html head area - it
 wouldn't work. You can read about this in common usage above.
 
+## gon.global
+
+Now you can use gon for sending your data to js from anywhere!
+
+It works just as simple `gon` but you need to write `Gon.global` instead of `gon` in your ruby code,
+`gon.global` in javascript and it will not clear self after each request. All other things the same.
+
+For example I want to tell anybody my application session secret token :) Now with Gon.global it's easy!
+
+`config/initializers/secret_token.rb`
+
+```ruby
+GonTest::Application.config.secret_token = 'You can't see my token'
+Gon.global.session = 'You can't see it I said'
+```
+
+`in some js which can reach window.gon variable`
+
+```javascript
+alert(gon.global.session)
+```
+
+Thats it!
+
 ## Installation
 
 Puts this line into `Gemfile` then run `$ bundle`:
 
 ``` ruby
-gem 'gon', '2.2.2'
+gem 'gon', '3.0.0'
 ```
 
 Or if you are old-school Rails 2 developer put this into `config/environment.rb` and run `$ rake gems:install`:
 
 ``` ruby
-config.gem 'gon', :version => '2.2.2'
+config.gem 'gon', :version => '3.0.0'
 ```
 
 Or manually install gon gem: `$ gem install gon`

data/lib/gon.rb

@@ -3,6 +3,9 @@ if defined?(Jbuilder)
 end
 require 'action_view'
 require 'action_controller'
+require 'gon/base'
+require 'gon/global'
+require 'gon/request'
 require 'gon/helpers'
 require 'gon/escaper'
 if defined?(Rabl)
@@ -15,107 +18,77 @@ end
 module Gon
   class << self
 
-    def all_variables
-      @request_env['gon']
-    end
-
-    def clear
-      @request_env['gon'] = {}
-    end
-
-    def request_env=(environment)
-      @request_env = environment
-      @request_env['gon'] ||= {}
-    end
-
-    def request_env
-      if defined?(@request_env)
-        return @request_env
-      end
-    end
-
-    def request
-      @request_id if defined? @request_id
-    end
-
-    def request=(request_id)
-      @request_id = request_id
+    def global
+      Gon::Global
     end
 
-    def method_missing(m, *args, &block)
-      if ( m.to_s =~ /=$/ )
-        if public_methods.include?(RUBY_VERSION > '1.9' ? m.to_s[0..-2].to_sym : m.to_s[0..-2])
+    def method_missing(method, *args, &block)
+      if ( method.to_s =~ /=$/ )
+        if public_method_name? method
           raise "You can't use Gon public methods for storing data"
         end
-        set_variable(m.to_s.delete('='), args[0])
+
+        set_variable(method.to_s.delete('='), args[0])
       else
-        get_variable(m.to_s)
+        get_variable(method.to_s)
       end
     end
 
-    def get_variable(name)
-      @request_env['gon'][name]
+    def all_variables
+      Request.gon
     end
 
-    def set_variable(name, value)
-      @request_env['gon'][name] = value
+    def clear
+      Request.clear
     end
 
-    %w(rabl jbuilder).each do |builder_name|
-      define_method builder_name do |*options|
-        if options.first.is_a? String
-          warn "[DEPRECATION] view_path argument is now optional. If you need to specify it please use #{builder}(:template => 'path')"
-          options = options.extract_options!.merge(:template => options[0])
-        else
-          options = (options && options.first.is_a?(Hash)) ? options.first : { }
-        end
+    def rabl(*args)
+      data, options = Gon::Rabl.handler(args)
 
-        builder_module = get_builder(builder_name)
+      store_builder_data 'rabl', data, options
+    end
 
-        data = builder_module.send("parse_#{builder_name}", get_template_path(options, builder_name), get_controller(options))
+    def jbuilder(*args)
+      data, options = Gon::Jbuilder.handler(args)
 
-        if options[:as]
-          set_variable(options[:as].to_s, data)
-        elsif data.is_a? Hash
-          data.each do |key, value|
-            set_variable(key, value)
-          end
-        else
-          set_variable(builder_name, data)
-        end
-      end
+      store_builder_data 'jbuilder', data, options
     end
-    alias_method :orig_jbuilder, :jbuilder
 
-    def jbuilder(*options)
-      orig_jbuilder(*options)
+    def inspect
+      'Gon'
     end
 
     private
 
-    def get_builder(builder_name)
-      begin
-        "Gon::#{builder_name.classify}".constantize
-      rescue
-        raise NoMethodError.new("You should define #{builder_name.classify} in your Gemfile")
-      end
+    def get_variable(name)
+      Request.gon[name]
     end
 
-    def get_controller(options)
-      options[:controller] ||
-        @request_env['action_controller.instance'] ||
-        @request_env['action_controller.rescue.response'].
-        instance_variable_get('@template').
-        instance_variable_get('@controller')
+    def set_variable(name, value)
+      Request.gon[name] = value
     end
 
-    def get_template_path(options, extension)
-      if options[:template]
-        File.extname(options[:template]) == ".#{extension}" ? options[:template] : "#{options[:template]}.#{extension}"
+    def store_builder_data(builder, data, options)
+      if options[:as]
+        set_variable(options[:as].to_s, data)
+      elsif data.is_a? Hash
+        data.each do |key, value|
+          set_variable(key, value)
+        end
       else
-        "app/views/#{get_controller(options).controller_path}/#{get_controller(options).action_name}.json.#{extension}"
+        set_variable(builder, data)
       end
     end
 
+    def public_method_name?(method)
+      public_methods.include?(
+        if RUBY_VERSION > '1.9'
+          method.to_s[0..-2].to_sym
+        else
+          method.to_s[0..-2]
+        end
+      )
+    end
+
   end
 end

data/lib/gon/base.rb

@@ -0,0 +1,58 @@
+module Gon
+  module Base
+    class << self
+
+      def render_data(options)
+        if Gon.global.all_variables.present?
+          Gon::Request.gon['global'] = Gon.global.all_variables
+        end
+        data = Gon.all_variables
+        namespace = options[:namespace] || 'gon'
+        start = '<script>window.' + namespace + ' = {};'
+        script = ''
+
+        if options[:camel_case]
+          data.each do |key, val|
+            script << "#{namespace}.#{key.to_s.camelize(:lower)}=#{val.to_json};"
+          end
+        else
+          data.each do |key, val|
+            script << "#{namespace}.#{key.to_s}=#{val.to_json};"
+          end
+        end
+
+        script = start + Gon::Escaper.escape(script) + '</script>'
+        script.html_safe
+      end
+
+      def get_controller(options)
+        options[:controller] ||
+          Gon::Request.env['action_controller.instance'] ||
+          Gon::Request.env['action_controller.rescue.response'].
+          instance_variable_get('@template').
+          instance_variable_get('@controller')
+      end
+
+      def get_template_path(options, extension)
+        if options[:template]
+          if right_extension?(extension, options[:template])
+            options[:template]
+          else
+            [options[:template], extension].join('.')
+          end
+        else
+          controller = get_controller(options).controller_path
+          action = get_controller(options).action_name
+          "app/views/#{controller}/#{action}.json.#{extension}"
+        end
+      end
+
+      private
+
+      def right_extension?(extension, template_path)
+        File.extname(template_path) == ".#{extension}"
+      end
+
+    end
+  end
+end

data/lib/gon/global.rb

@@ -0,0 +1,68 @@
+module Gon
+  module Global
+    class << self
+
+      def all_variables
+        @global_vars || {}
+      end
+
+      def method_missing(method, *args, &block)
+        @global_vars ||= {}
+        if ( method.to_s =~ /=$/ )
+          if public_method_name? method
+            raise "You can't use Gon public methods for storing data"
+          end
+
+          @global_vars[method.to_s.delete('=')] = args[0]
+        else
+          @global_vars[method.to_s]
+        end
+      end
+
+      def rabl(*args)
+        data, options = Gon::Rabl.handler(args, true)
+
+        store_builder_data 'rabl', data, options
+      end
+
+      def jbuilder(*args)
+        data, options = Gon::Jbuilder.handler(args, true)
+
+        store_builder_data 'jbuilder', data, options
+      end
+
+      def clear
+        @global_vars = {}
+      end
+
+      def inspect
+        'Gon'
+      end
+
+      private
+
+      def store_builder_data(builder, data, options)
+        if options[:as]
+          @global_vars[options[:as].to_s] = data
+        elsif data.is_a? Hash
+          data.each do |key, value|
+            @global_vars[key] = value
+          end
+        else
+          @global_vars[builder] = data
+        end
+      end
+
+      def public_method_name?(method)
+        public_methods.include?(
+          if RUBY_VERSION > '1.9'
+            method.to_s[0..-2].to_sym
+          else
+            method.to_s[0..-2]
+          end
+        )
+      end
+
+    end
+  end
+end

data/lib/gon/helpers.rb

@@ -8,27 +8,24 @@ module Gon
     module InstanceMethods
 
       def include_gon(options = {})
-        if Gon.request_env && Gon.all_variables.present? && Gon.request == request.object_id
-          data = Gon.all_variables
-          namespace = options[:namespace] || 'gon'
-          start = '<script>window.' + namespace + ' = {};'
-          script = ''
-          if options[:camel_case]
-            data.each do |key, val|
-              script << namespace + '.' + key.to_s.camelize(:lower) + '=' + val.to_json + ';'
-            end
-          else
-            data.each do |key, val|
-              script << namespace + '.' + key.to_s + '=' + val.to_json + ';'
-            end
-          end
-          script = start + Gon::Escaper.escape(script) + '</script>'
-          script.html_safe
+        if variables_for_request_present?
+          Gon::Base.render_data(options)
+        elsif Gon.global.all_variables.present?
+          Gon.clear
+          Gon::Base.render_data(options)
         else
           ""
         end
       end
 
+      private
+
+      def variables_for_request_present?
+        Gon::Request.env &&
+        Gon::Request.id == request.object_id &&
+        Gon.all_variables.present?
+      end
+
     end
   end
 
@@ -41,13 +38,20 @@ module Gon
     module InstanceMethods
 
       def gon
-        if !Gon.request_env || Gon.request != request.object_id
-          Gon.request = request.object_id
-          Gon.request_env = request.env
+        if wrong_gon_request?
+          Gon::Request.id = request.object_id
+          Gon::Request.env = request.env
         end
         Gon
       end
 
+      private
+
+      def wrong_gon_request?
+        Gon::Request.env.blank? ||
+        Gon::Request.id != request.object_id
+      end
+
     end
 
   end

data/lib/gon/jbuilder.rb

@@ -2,21 +2,61 @@ module Gon
   module Jbuilder
     class << self
 
-      def parse_source(source, controller)
-        output = ::JbuilderTemplate.encode(controller) do |json|
-          eval source
+      def handler(args, global = false)
+        options = parse_options_from args
+        if global && !options[:template]
+          raise 'You should provide :template when use rabl with global variables'
+        end
+
+        data = parse_jbuilder \
+          Gon::Base.get_template_path(options,'jbuilder'),
+          Gon::Base.get_controller(options)
+
+        [data, options]
+      end
+
+      private
+
+      def parse_options_from(args)
+        if old_api? args
+          text =  "[DEPRECATION] view_path argument is now optional. "
+          text << "If you need to specify it, "
+          text << "please use gon.rabl(:template => 'path')"
+          warn text
+
+          args.extract_options!.merge(:template => args[0])
+        elsif new_api? args
+          args.first
+        else
+          {}
         end
-        JSON.parse(output)
+      end
+
+      def old_api?(args)
+        args.first.is_a? String
+      end
+
+      def new_api?(args)
+        args.first.is_a? Hash
       end
 
       def parse_jbuilder(jbuilder_path, controller)
         controller.instance_variables.each do |name|
-          self.instance_variable_set(name, controller.instance_variable_get(name))
+          self.instance_variable_set \
+            name,
+            controller.instance_variable_get(name)
         end
-        lines = find_partials(File.readlines(jbuilder_path))
+        lines = find_partials File.readlines(jbuilder_path)
         source = lines.join('')
 
-        output = parse_source(source, controller)
+        output = parse_source source, controller
+      end
+
+      def parse_source(source, controller)
+        output = ::JbuilderTemplate.encode(controller) do |json|
+          eval source
+        end
+        JSON.parse(output)
       end
 
       def parse_partial(partial_line)
@@ -29,7 +69,7 @@ module Gon
             eval "def #{name}; self.instance_variable_get('@' + '#{name.to_s}'); end"
           end
         end
-        find_partials(File.readlines(path))
+        find_partials File.readlines(path)
       end
 
       def find_partials(lines = [])