gaq 0.2.0

data/lib/gaq/controller_facade.rb

@@ -0,0 +1,15 @@
+module Gaq
+  class ControllerFacade
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def flash
+      @controller.flash
+    end
+
+    def evaluate_config_lambda(lmbda)
+      lmbda.call(@controller)
+    end
+  end
+end

data/lib/gaq/controller_handle.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+require 'gaq/dsl_target_factory'
+require 'gaq/flash_commands_adapter'
+require 'gaq/interprets_config'
+
+module Gaq
+  class ControllerHandle
+    include InterpretsConfig
+
+    attr_writer :flash_commands_adapter
+
+    def initialize(controller_facade, language, class_cache, config)
+      @controller_facade, @language, @class_cache, @config =
+        controller_facade, language, class_cache, config
+    end
+
+    def root_target
+      @root_target ||= target_factory.root_target
+    end
+
+    def immediate_commands
+      @immediate_commands ||= flash_commands_adapter.commands_from_flash
+    end
+
+    def finalized_commands_as_segments
+      commands = immediate_commands.dup
+      commands << @language.new_command(:anonymize_ip) if interpret_config(@config.anonymize_ip)
+
+      setup_tracker_names = [nil, *track_pageview_tracker_names, *seen_tracker_names].uniq
+      setup_tracker_names.each do |tracker_name|
+        tracker_config = @config.tracker_config(tracker_name)
+        commands += tracker_setup_commands(tracker_config) if tracker_config
+      end
+
+      @language.sort_commands(commands)
+      @language.commands_to_segments_for_to_json(commands)
+    end
+
+    private
+
+    def interpret_config(value)
+      super(value, @controller_facade)
+    end
+
+    def seen_tracker_names
+      immediate_commands.map(&:tracker_name).uniq
+    end
+
+    def track_pageview_tracker_names
+      @config.tracker_names.select do |tracker_name|
+        @config.tracker_config(tracker_name).track_pageview?
+      end
+    end
+
+    def tracker_setup_commands(tracker_config)
+      [set_account_command(tracker_config), track_pageview_command(tracker_config)].compact
+    end
+
+    def track_pageview_command(tracker_config)
+      return nil unless tracker_config.track_pageview?
+
+      command = @language.new_command(:track_pageview)
+      command.tracker_name = tracker_config.tracker_name
+      command
+    end
+
+    def set_account_command(tracker_config)
+      web_property_id = interpret_config(tracker_config.web_property_id)
+      command = @language.new_command(:set_account, web_property_id)
+      command.tracker_name = tracker_config.tracker_name
+      command
+    end
+
+    def target_factory
+      @target_factory ||= DslTargetFactory.new(
+        @class_cache, flash_commands_adapter, immediate_commands,
+        new_command_proc, variables, @config.tracker_names)
+    end
+
+    def flash_commands_adapter
+      @flash_commands_adapter ||= FlashCommandsAdapter.new(@language, @controller_facade)
+    end
+
+    def new_command_proc
+      @language.method(:new_command)
+    end
+
+    def variables
+      @config.variables.values
+    end
+  end
+end

data/lib/gaq/dsl_target.rb

@@ -0,0 +1,51 @@
+module Gaq
+  class DslTarget
+    def initialize(target_factory, factory_token, new_command_proc, commands, tracker_name)
+      @target_factory, @factory_token, @new_command_proc, @commands, @tracker_name =
+        target_factory, factory_token, new_command_proc, commands, tracker_name
+    end
+
+    def tracker(tracker_name)
+      @target_factory.target_with_tracker_name(tracker_name, @factory_token)
+    end
+
+    alias_method :[], :tracker
+
+    def next_request
+      @target_factory.target_for_next_request(@factory_token)
+    end
+
+    ## tracker methods
+
+    def track_event(category, action, label = nil, value = nil, noninteraction = nil)
+      array = [noninteraction, value, label, action, category]
+      4.times do
+        if array.first.nil?
+          array.shift
+        else
+          break
+        end
+      end
+
+      command = @new_command_proc.call(:track_event, *array.reverse)
+      command.tracker_name = @tracker_name
+      @commands << command
+    end
+
+    class << self
+      def variable_commands_module(variables)
+        Module.new do
+          variables.each do |variable|
+            module_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+              def #{variable.name}=(value)
+                command = @new_command_proc.call(:set_custom_var, #{variable.slot}, #{variable.name.inspect}, value, #{variable.scope})
+                command.tracker_name = @tracker_name
+                @commands << command
+              end
+            RUBY_EVAL
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gaq/dsl_target_factory.rb

@@ -0,0 +1,64 @@
+require 'gaq/dsl_target'
+require 'gaq/command_language'
+
+module Gaq
+  class DslTargetFactory
+    attr_writer :target_base_class #for injecting
+
+    def initialize(class_cache, flash_commands_adapter, immediate_commands, new_command_proc, variables, tracker_names)
+      @class_cache = class_cache
+      @flash_commands_adapter = flash_commands_adapter
+      @immediate_commands = immediate_commands
+      @new_command_proc = new_command_proc
+      @variables = variables
+      @tracker_names = tracker_names
+    end
+
+    def root_target
+      target_for_token(Token.new)
+    end
+
+    def target_with_tracker_name(tracker_name, token)
+      tracker_name = tracker_name.to_s unless tracker_name.nil?
+      raise "No tracker by name #{tracker_name.inspect}" unless @tracker_names.include?(tracker_name)
+
+      token = token.dup
+      token.tracker_name = tracker_name
+      target_for_token(token)
+    end
+
+    def target_for_next_request(token)
+      token = token.dup
+      token.next_request = true
+      target_for_token(token)
+    end
+
+    private
+
+    Token = Struct.new(:tracker_name, :next_request) do
+      alias_method :next_request?, :next_request
+    end
+
+    def target_for_token(token)
+      commands = token.next_request? ? @flash_commands_adapter : @immediate_commands
+      target_class.new(self, token, @new_command_proc, commands, token.tracker_name)
+    end
+
+    def target_base_class
+      @target_base_class || DslTarget
+    end
+
+    def target_class
+      ensure_class_cache_set_up
+      @class_cache[:target_class]
+    end
+
+    def ensure_class_cache_set_up
+      @class_cache_set_up ||= true.tap do
+        @class_cache.building(:target_class, target_base_class) do |cls|
+          cls.send :include, target_base_class.variable_commands_module(@variables)
+        end
+      end
+    end
+  end
+end

data/lib/gaq/flash_commands_adapter.rb

@@ -0,0 +1,48 @@
+module Gaq
+  class FlashCommandsAdapter
+    def initialize(language, controller_facade)
+      @language, @controller_facade = language, controller_facade
+      @commands = []
+    end
+
+    def <<(command)
+      @commands << command
+      set_flash
+    end
+
+    FLASH_KEY = :gaqgem
+
+    # bump this every time picking up old data from a flash
+    # (which is part of the session cookie)
+    # might break things
+    FLASH_FORMAT_VERSION = 1
+
+    def commands_from_flash
+      flash_data = @controller_facade.flash[FLASH_KEY]
+      flash_data = [FLASH_FORMAT_VERSION] unless flash_data_current?(flash_data)
+
+      flash_items = flash_data.drop(1)
+      @language.commands_from_flash_items(flash_items)
+    end
+
+    private
+
+    def set_flash
+      @controller_facade.flash[FLASH_KEY] = [
+        FLASH_FORMAT_VERSION,
+        *@language.commands_to_flash_items(@commands)
+      ]
+    end
+
+    def flash_data_current?(flash_data)
+      # flash_data may be nil (nothing in flash yet) or an array.
+      return false unless flash_data
+
+      # flash data is legacy unless first array item is a Fixnum
+      return false unless flash_data.first.is_a?(Fixnum)
+
+      # Mismatching versions are not current.
+      flash_data.first == FLASH_FORMAT_VERSION
+    end
+  end
+end

data/lib/gaq/interprets_config.rb

@@ -0,0 +1,13 @@
+module Gaq
+  module InterpretsConfig
+    private
+
+    def interpret_config(value, controller_facade)
+      if value.respond_to?(:call)
+        controller_facade.evaluate_config_lambda(value)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/gaq/railtie.rb

@@ -0,0 +1,40 @@
+require 'gaq/configuration'
+require 'gaq/command_language'
+require 'gaq/class_cache'
+require 'gaq/controller_facade'
+require 'gaq/controller_handle'
+require 'gaq/snippet_renderer'
+
+module Gaq
+  module Helper
+    def render_gaq
+      renderer = SnippetRenderer.new(self, Configuration.singleton, Rails.env)
+      renderer.render(_gaq_handle.finalized_commands_as_segments)
+    end
+  end
+
+  module ControllerMethods
+    def _gaq_handle
+      @_gaq ||= ControllerHandle.new(
+        ControllerFacade.new(self),
+        CommandLanguage.singleton,
+        ClassCache.singleton,
+        Configuration.singleton
+      )
+    end
+
+    def gaq
+      _gaq_handle.root_target
+    end
+  end
+
+  class Railtie < Rails::Railtie
+    config.gaq = Configuration.singleton.rails_config
+
+    initializer "gaq.include_helper" do |app|
+      ActionController::Base.send :include, ControllerMethods
+      ActionController::Base.helper Helper
+      ActionController::Base.helper_method :_gaq_handle
+    end
+  end
+end

data/lib/gaq/snippet_renderer.rb

@@ -0,0 +1,44 @@
+require 'json'
+
+module Gaq
+  class SnippetRenderer
+
+    SNIPPET = <<EOJ
+(function() {
+  var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+  ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+  (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(ga);
+})();
+EOJ
+
+    def initialize(rendering_context, config, rails_env)
+      @context = rendering_context
+      @config = config
+      @rails_env = rails_env
+    end
+
+    def render(commands_as_segments)
+      js_content_lines = [
+        'var _gaq = _gaq || [];',
+        "_gaq.push(#{escape_instructions(commands_as_segments).join(",\n  ")});"
+      ]
+
+      js_content = js_content_lines.join("\n")
+      js_content << "\n\n" << SNIPPET if render_ga_js?
+
+      return @context.javascript_tag js_content
+    end
+
+    private
+
+    def escape_instructions(commands_as_segments)
+      commands_as_segments.map do |command_as_segments|
+        command_as_segments.to_json
+      end
+    end
+
+    def render_ga_js?
+      @config.render_ga_js?(@rails_env)
+    end
+  end
+end

data/lib/gaq/version.rb

@@ -0,0 +1,3 @@
+module Gaq
+  VERSION = "0.2.0"
+end

data/spec-dummy/.rspec

@@ -0,0 +1 @@
+--color

data/spec-dummy/README.rdoc

@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |       |-- images
+  |       |-- javascripts
+  |       `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      |-- assets
+          `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.