omniturize 0.0.3

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in omniturize.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Alexandru Catighera
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,139 @@
+# Omniturize
+This gem integrates Omniture SiteCatalyst into your web app. 
+
+## Installation
+    gem install omniturize
+
+## Based on and unaware collaborators
+This is gem is based on [activenetwork's OmnitureClient gem](https://github.com/activenetwork/omniture_client, "activenetwork's OmnitureClient"), which was forked from [acatighera's](https://github.com/acatighera/omniture_client, "acatighera's OmnitureClient").
+
+There is some borrowed code from unawared coders. So thank you to
+
+*   [acatighera](https://github.com/acatighera, "acatighera github homepage")
+*   [activenetwork](https://github.com/activenetwork, "activenetwork github homepage")
+*   [John Nunemaker](http://railstips.org/about, "railstips") for his [ClassLevelInheritableAttributes solution](http://railstips.org/blog/archives/2006/11/18/class-and-instance-variables-in-ruby/, "Class and instance variables in ruby")
+
+## Configuration
+You must configure the Omniture namespace, suite(s), version that you wish to use.
+Optionally, you can set up aliases to make things easier for yourself when coding reporters. Omniture uses c1, e1, r, etc to represent custom variables, e_vars, the referrer, etc. These param names are obscure and can be hard to remember so you can set up aliases for them.
+
+    # config/omniture.yml
+    development:
+      base_url: http://102.112.2O7.net
+      ssl_url: https://102.112.2O7.net
+      suite: suite1
+      version: G.4--NS
+      aliases:
+        search_term: c1
+        movie_titles: e1
+        referrer: r
+
+Then, you should add this line to an initializer:
+
+	Omniturize::config(YAML::load(File.open("#{Rails.root}/config/omniture.yml"))[Rails.env])
+
+## Usage
+###Attaching to the controllers
+You can select which controllers you want to track by adding the next line
+
+	class FooController < ApplicationController
+		 omniturize
+	end
+
+For each controller you want to track, you should create a reporter. The root name of this reporter should be the same name as the controller -or the `BasicController` explained below.
+
+
+	#FooReporter for FooController
+	class FooReporter < Omniturize::Base
+		...
+	end
+
+If there is a basic behaviour for some of your controllers, you should create a BasicReporter. This reporter will be used in case a reporter with the same name as the controller is not found.
+
+	#BasicReporter
+	class BasicReporter < Omniturize::Base
+		...
+	end
+
+
+###vars
+You can define a var by giving it a name and defining a block
+
+
+	var :my_var do
+		params[:id]
+	end
+
+
+You can define a var to be present in or excluded from some actions.
+
+	#This var will be present only in index and new actions
+	var :my_var, :only => [:index, :new] do
+		'value_for_my_var'
+	end
+
+	#this var will be excluded from index, new, create, update and destroy actions
+
+	var :my_var, :except => [:index, :new, :create, :update, :destroy] do
+		params[:id]
+	end
+
+
+If no :only or :excluded options are passed, the defined var will be available in every action.
+
+###Events
+You can define an event the same way you define a var, except that you don't have to give a name for the event
+
+	event, :only => [:search] do
+		'my_event'
+	end
+
+###Custom javascript
+You can define custom javascript code the same way you define an event
+
+	js_snippet, :only => [:search] do
+		's.server = window.location.host;'
+	end
+
+###Using controller methods in the blocks
+Since the block you are defining is executed within the controller context, you can use every method defined in your controller.
+
+##File structure
+My advice is to create these reporters in the 'app/reporters' directory, by creating this directory and adding it to the autoload_path
+
+	config.autoload_paths += "#{RAILS_ROOT}/app/reporters"
+
+You can create a hierarchy of reporters. This way you can share some configurations between classes and override them if necessary, e.g: you would want to create an ApplicationReporter which will contain the most common behaviour, and subclass this reporter for adding or modifying new vars, events, or js
+
+
+	class ApplicationReporter < Omniturize::Base
+		var :my_var do
+			'common value'
+		end
+	end
+
+	class FooReporter < ApplicationReporter
+		var :my_var do
+			'foo'
+		end
+
+		var :foo_var do
+			'foo2'
+		end
+	end
+
+
+## Views
+Somewhere in your view -probably in one of your layouts- you should add the next line:
+
+
+	@controller.reporter.js(:action => params[:action])
+
+
+##More info
+Since this gem has been created for a very specific use, it may be that this documentation is not enough for you. I have tried to keep the most code from the original sources, so you would want to take a look to the code itself or to the original sources where I took the code
+
+* [OmnitureClient gem](https://github.com/acatighera/omniture_client, "acathigera's OmnitureClient")
+* [activenetwork's fork](https://github.com/activenetwork/omniture_client, "activenetwork's OmnitureClient")
+
+##### Copyright (c) 2011 Javier Lafora, released under MIT license

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/class_level_inheritable_attributes.rb

@@ -0,0 +1,31 @@
+# This code was proudly and shamelessly copied from
+# http://railstips.org/blog/archives/2006/11/18/class-and-instance-variables-in-ruby/
+# so let's all thank John Nunemaker with a loud and strong applause: PLAS!!!!'
+
+module Omniturize
+  module ClassLevelInheritableAttributes
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def inheritable_attributes(*args)
+        @omniture_inheritable_attributes ||= [:omniture_inheritable_attributes]
+        @omniture_inheritable_attributes += args
+        args.each do |arg|
+          class_eval %(
+            class << self; attr_accessor :#{arg} end
+          )
+        end
+        @omniture_inheritable_attributes
+      end
+
+      def inherited(subclass)
+        @omniture_inheritable_attributes.each do |inheritable_attribute|
+          instance_var = "@#{inheritable_attribute}"
+          subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+        end
+      end
+    end
+  end
+end

data/lib/omniturize/base.rb

@@ -0,0 +1,104 @@
+module Omniturize
+  class Base
+
+    include Omniturize::ClassLevelInheritableAttributes
+    include Omniturize::Printer
+    inheritable_attributes :meta_vars, :meta_js_events, :meta_js_snippets
+    
+    attr_reader  :controller
+
+    @meta_vars = []
+    @meta_js_events = []
+    @meta_js_snippets   = []
+
+
+    class << self
+      attr_accessor :meta_vars, :meta_js_events, :meta_js_snippets
+      @@controller = nil
+
+      def var(name, options={}, &block)
+        meta_var = Omniturize::MetaVar.new(name.to_s, options)
+        meta_var.add_var(block)
+        meta_vars.insert(0, meta_var) unless meta_vars.include?(meta_var)
+        meta_var
+      end
+
+      def event(options = {}, &block)
+        meta_js(meta_js_events, block, options)
+      end
+
+      def js_snippet(options = {}, &block)
+        meta_js(meta_js_snippets, block, options)
+      end
+
+      def find_meta_vars(name, action = nil)
+        filter_collection_for_action(meta_vars.select{|x|x.matches_name?(name)}, action).uniq_by(:name)
+      end
+
+      def filter_collection_for_action(collection, action)
+        return collection if action.blank?
+        collection.select do |element|
+          (element.only.present? && element.only.include?(action.try(:to_sym))) ||
+          (element.except.present? && !element.except.include?(action.try(:to_sym))) ||
+          (element.only.blank? && element.except.blank?)
+        end
+      end
+
+      protected
+
+      def meta_js(collection, block, options = {})
+        meta_js = Omniture::MetaJs.new(options)
+        meta_js.add_js(block)
+        collection.insert(0, meta_js)
+        meta_js
+      end
+
+    end
+
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def vars(options = {})
+      meta_collection_to_values(self.class.meta_vars, options[:action]).uniq_by(:name)
+    end
+    
+    def js_events(options = {})
+      meta_collection_to_values(self.class.meta_js_events, options[:action]).uniq
+    end
+
+    def js_snippets(options = {})
+      meta_collection_to_values(self.class.meta_js_snippets, options[:action]).uniq
+    end
+
+    def add_var(name, value)
+      self.class.var(name) do
+        value
+      end
+    end
+
+    def find_var(name, options = {})
+      vars(options[:action]).detect{|x|x.matches_name?(name)}
+    end
+
+    def meta_vars_to_vars(meta_vars)
+      meta_vars.inject([]) do |vars, meta_var|
+        vars << meta_var.value(controller) if meta_var
+        vars
+      end
+    end
+
+    protected
+
+    def build_js_collection(procs_collection)
+      procs_collection.inject([]) do |code, js|
+        code << controller.instance_eval(&js)
+        code
+      end
+    end
+
+    def meta_collection_to_values(collection, action = nil)
+      action.present? ? meta_vars_to_vars(self.class.filter_collection_for_action(collection, action)): meta_vars_to_vars(collection)
+    end
+  end
+end

data/lib/omniturize/meta_js.rb

@@ -0,0 +1,42 @@
+module Omniture
+  class MetaJs
+    attr_reader :cache_key, :expires_in, :only, :except, :delimiter
+    attr_accessor :value_procs
+
+    DEFAULT_OPTIONS = { :unique => nil,
+                        :expires_in => 0,
+                        :only => [],
+                        :except => [],
+                        :delimiter => ','
+    }
+
+    def initialize(options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+      
+      @value_procs = []
+      @cache_key = "omniture/#{Time.now.to_i}/#{options[:unique]}"
+      @expires_in = options[:expires_in]
+      @only = options[:only]
+      @except = options[:except]
+    end
+
+    def add_js(value_proc)
+      value_procs << value_proc
+    end
+
+    def value(scope)
+      if @expires_in > 0
+        Rails.cache.fetch(@cache_key, :expires_in => @expires_in) do
+          return_var(scope)
+        end
+      else
+        return_var(scope)
+      end
+    end
+
+    def return_var(scope)
+      value_procs.map{ |p| scope.instance_eval(&p) }.flatten.uniq.join(delimiter)
+      #scope.instance_eval(&p)
+    end
+  end
+end

data/lib/omniturize/meta_var.rb

@@ -0,0 +1,53 @@
+module Omniturize
+  class MetaVar
+
+    DEFAULT_OPTIONS = { :delimiter => ',',
+                        :unique => nil,
+                        :expires_in => 0,
+                        :only => [],
+                        :except => []
+    }
+
+    attr_reader :name, :delimiter, :cache_key, :expires_in, :only, :except
+    attr_accessor :value_procs
+
+    def initialize(name, options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+      @name = name
+      @value_procs = []
+      @delimiter = options[:delimiter]
+      @cache_key = "omniture/#{name}/#{options[:unique]}"
+      @expires_in = options[:expires_in]
+      @only = Array(options[:only])
+      @except = Array(options[:except])
+    end
+
+    def add_var(value_proc)
+      value_procs << value_proc
+    end
+
+    # wrap up the value in a Var object and cache if needed
+    def value(scope)
+      if @expires_in > 0
+        Rails.cache.fetch(@cache_key, :expires_in => @expires_in) do
+          return_var(scope)
+        end
+      else
+        return_var(scope)
+      end
+    end
+    
+    def return_var(scope)
+      Var.new(name, value_procs.map{ |p| scope.instance_eval(&p) }.flatten.uniq.join(delimiter))
+    end
+
+    def matches_name?(name)
+      select_condition = case name
+        when Regexp then self.name.match(name)
+        when String then self.name == name
+        else raise ArgumentError.new('name must be a String or a Regexp')
+      end
+    end
+    
+  end
+end

data/lib/omniturize/printer.rb

@@ -0,0 +1,62 @@
+module Omniturize
+  module Printer
+
+    def url(ssl = false)
+      suite = Omniturize::suite.is_a?(Array) ? Omniturize::suite.join(',') : Omniturize::suite
+      base_url =  ssl == :ssl ? Omniturize::ssl_url : Omniturize::base_url
+      "#{base_url}/b/ss/#{suite}/#{Omniturize::version}/#{rand(9999999)}?#{query}"
+    end
+    
+    def js(options = {})
+      output = <<-JS
+        <script type="text/javascript" language="JavaScript" src="#{Omniturize::js_src}"></script>
+        <script type="text/javascript" language="JavaScript">
+          #{js_vars(options)}
+          #{print_js_events(options)}
+          #{print_js_snippets(options)}
+          var s_code=s.t();if(s_code)document.write(s_code)
+        </script>
+      JS
+    end
+    
+    def query(options = {})
+      vars(options).inject([]) do |query, var|
+        query << var_to_query(var) if var.value && var.value != ""
+        query
+      end.join('&')
+    end
+    
+    def js_vars(options = {})
+      vars(options).inject([]) do |query, var|
+        query << var_to_js(var) if var.value && var.value != ""
+        query
+      end.join(";\n") + ';'
+    end
+    
+    def raw_vars(options = {})
+      vars(options).inject([]) do |query, var|
+        query << { var.name.to_sym => var.value } if var.value && var.value != ""
+        query
+      end
+    end
+
+    def print_js_events(options = {})
+      values = js_events(options).join(',')
+      values.blank? ? nil : "s.events = \"#{values}\""
+    end
+
+    def print_js_snippets(options = {})
+      js_snippets(options).join("\n")
+    end
+    
+    private
+
+    def var_to_query(var)
+      "#{ CGI::escape(var.name) }=#{ CGI::escape(var.value) }" if var
+    end
+    
+    def var_to_js(var)
+      %Q{\t#{Omniturize::var_prefix + '.' if Omniturize::var_prefix}#{var.name}="#{var.value}"} if var
+    end
+  end
+end

data/lib/omniturize/var.rb

@@ -0,0 +1,22 @@
+module Omniturize
+  class Var
+    attr_reader :name, :value
+    def initialize(name, value)
+      if Omniturize::aliases && Omniturize::aliases[name.to_s]
+        @name = Omniturize::aliases[name.to_s]
+      else
+        @name = name.to_s
+      end
+      @value = value
+    end
+
+    def matches_name?(name)
+      select_condition = case name
+        when Regexp then self.name.match(name)
+        when String then self.name == name
+        else raise ArgumentError.new('name must be a String or a Regexp')
+      end
+    end
+
+  end
+end

data/lib/omniturize/version.rb

@@ -0,0 +1,3 @@
+module Omniturize
+  VERSION = "0.0.3"
+end

data/lib/omniturize.rb

@@ -0,0 +1,26 @@
+require "omniturize/version"
+require File.dirname(__FILE__) + '/class_level_inheritable_attributes'
+require File.dirname(__FILE__) + '/omniturize/printer'
+require File.dirname(__FILE__) + '/omniturize/base'
+require File.dirname(__FILE__) + '/omniturize/var'
+require File.dirname(__FILE__) + '/omniturize/meta_js'
+require File.dirname(__FILE__) + '/omniturize/meta_var'
+require 'cgi'
+
+module Omniturize
+
+  class << self
+    def config(config_hash)
+      config_hash.each do |key, val|
+        module_eval do
+          mattr_accessor key.to_sym
+        end
+        send("#{key}=", val)
+      end
+    end
+  end
+end
+
+if defined?(Rails)
+  require File.dirname(__FILE__) + '/omniturize_rails'
+end

data/lib/omniturize_rails.rb

@@ -0,0 +1,34 @@
+module Omniturize
+  module ActionControllerMethods
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def omniturize(options = {})
+        include InstanceMethods
+        before_filter :set_reporter, options
+        attr_accessor :reporter
+      end
+    end
+
+    module InstanceMethods
+
+      private
+
+      def set_reporter(options = {})
+
+        @reporter ||=  begin
+          options[:controller].present? ? "#{options[:controller].classify}Reporter".constantize.new(self) :
+                                          "#{self.controller_name.capitalize}Reporter".constantize.new(self)
+        rescue NameError
+          BasicReporter.new(self)
+        end
+      end
+
+    end
+  end
+end
+
+ActionController::Base.send(:include, Omniturize::ActionControllerMethods) if defined?(ActionController::Base)

data/omniturize.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "omniturize/version"
+
+Gem::Specification.new do |s|
+  s.name        = "omniturize"
+  s.version     = Omniturize::VERSION
+  s.authors     = ["eLafo"]
+  s.email       = ["javierlafora@gmail.com"]
+  s.homepage    = "https://github.com/eLafo/omniturize"
+  s.summary     = %q{This gem integrates Omniture SiteCatalyst into your web app}
+  s.description = %q{This gem integrates Omniture SiteCatalyst into your web app. You can specify vars, events and custom javascript for every action of a controller. This gem is proudly based on the omniture_client gem, from which it takes much code and ideas}
+
+  s.rubyforge_project = "omniturize"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: omniturize
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- eLafo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-13 00:00:00 Z
+dependencies: []
+
+description: This gem integrates Omniture SiteCatalyst into your web app. You can specify vars, events and custom javascript for every action of a controller. This gem is proudly based on the omniture_client gem, from which it takes much code and ideas
+email: 
+- javierlafora@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- lib/class_level_inheritable_attributes.rb
+- lib/omniturize.rb
+- lib/omniturize/base.rb
+- lib/omniturize/meta_js.rb
+- lib/omniturize/meta_var.rb
+- lib/omniturize/printer.rb
+- lib/omniturize/var.rb
+- lib/omniturize/version.rb
+- lib/omniturize_rails.rb
+- omniturize.gemspec
+homepage: https://github.com/eLafo/omniturize
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: omniturize
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: This gem integrates Omniture SiteCatalyst into your web app
+test_files: []
+