gxapi_rails 0.0.2

data/lib/gxapi/base.rb

@@ -0,0 +1,100 @@
+module Gxapi
+  class Base
+
+    TIMEOUT = 2.0
+
+    attr_reader :user_key
+
+    #
+    # @param user_key [String] identifier for our user - this is used in
+    # the cache_key
+    def initialize(user_key)
+      @user_key = user_key
+      @interface = GoogleAnalytics.new
+    end
+
+    # get the {Gxapi.env}
+    def env
+      Gxapi.env
+    end
+
+    #
+    # get all experiments
+    #
+    # @return [Array<Ostruct>]
+    def get_experiments
+      @interface.get_experiments
+    end
+
+    #
+    # return a variant value
+    #
+    # @example
+    #   variant = @gxapi.get_variant("my_experiment")
+    #   variant.value =>
+    #     # Ostruct.new(experiment_id: "x", index: 1, name: "name")
+    #
+    # @return [Celluloid::Future]
+    def get_variant(experiment_name, override = nil)
+      Celluloid::Future.new do
+        # allows us to override and get back a variant
+        # easily that conforms to the api
+        if override.nil?
+          self.get_variant_value(experiment_name)
+        else
+          Ostruct.new(self.default_values.merge(name: override))
+        end
+      end
+    end
+
+    #
+    # reload the experiment cache from the remote
+    #
+    # @return [Boolean] true
+    def reload_experiments
+      @interface.reload_experiments
+      true
+    end
+
+    protected
+
+    #
+    # cache key for a given experiment and our user
+    #
+    # @param experiment_name [String] The name of our experiment
+    #
+    # @return [String] The cache key
+    def cache_key(experiment_name)
+      experiment_name = experiment_name.downcase.gsub(/\s+/,'_')
+      "#{Gxapi.cache_namespace}#{self.user_key}_#{experiment_name}"
+    end
+
+    #
+    # Default hash values for when a variant isn't found
+    #
+    # @return [Hash] Default values for when something goes wrong
+    def default_values
+      {name: "default", index: -1, experiment_id: nil}
+    end
+
+    #
+    # protected method to make the actual calls to get values
+    # from the cache or from Google
+    #
+    # @param experiment_name [String] Experiment name to look for
+    #
+    # @return [Gxapi::Ostruct] Experiment data
+    def get_variant_value(experiment_name)
+      data = Gxapi.with_error_handling do
+        Timeout::timeout(2.0) do
+          Gxapi.cache.fetch(self.cache_key(experiment_name)) do
+            @interface.get_variant(experiment_name).to_hash
+          end
+        end
+      end
+      Ostruct.new(
+        data.is_a?(Hash) ? data : self.default_values
+      )
+    end
+  end
+end

data/lib/gxapi/controller_methods.rb

@@ -0,0 +1,41 @@
+module Gxapi
+  module ControllerMethods
+
+    #
+    # Get the variant and set it as an instance variable, handling
+    # overriding by passing in the URL
+    #
+    # @param  experiment_name [String] Name for the experiment
+    # @param  ivar_name [String, Symbol] Name for the variable
+    #
+    # @return [Celluloid::Future, Gxapi::Ostruct] Variant value
+    def gxapi_get_variant(experiment_name, ivar_name = :variant)
+      # handle override
+      if params[ivar_name]
+        val = Gxapi::Ostruct.new(
+          value: {
+            index: -1,
+            experiment_id: nil,
+            name: params[ivar_name]
+          }
+        )
+      else
+        val = self.gxapi_base.get_variant(experiment_name)
+      end
+      return instance_variable_set("@#{ivar_name}", val)
+    end
+
+    protected
+
+    def gxapi_base
+      @gxapi_base ||= begin
+        Gxapi::Base.new(self.gxapi_token)
+      end
+    end
+
+    def gxapi_token
+      cookies[:gxapi] ||= SecureRandom.hex(16)
+    end
+
+  end
+end

data/lib/gxapi/engine.rb

@@ -0,0 +1,14 @@
+if Rails::VERSION::MAJOR >= 3
+  module Gxapi
+    class Engine < Rails::Engine
+      config.after_initialize do
+        Gxapi.cache = Rails.cache
+        # add our helper
+        ApplicationHelper.send(:include, GxapiHelper)
+        ApplicationController.send(:include, Gxapi::ControllerMethods)
+      end
+    end
+  end
+else
+  require File.expand_path('../../../app/helpers/gxapi_helper', __FILE__)
+end

data/lib/gxapi/google_analytics.rb

@@ -0,0 +1,193 @@
+require 'google/api_client'
+
+module Gxapi
+  class GoogleAnalytics
+
+    CACHE_KEY = "gxapi-google-analytics-experiments"
+
+    #
+    # Gets the experiment that has this name
+    #
+    # @param name [String] Name of the experiment
+    #
+    # @return [Gxapi::Ostruct]
+    def get_experiment(name)
+      self.get_experiments.find{|experiment| experiment.name == name}
+    end
+
+    #
+    # return a list of all experiments
+    #
+    # @return [Array<Gxapi::Ostruct>]
+    def get_experiments
+      @experiments ||= begin
+        # fetch our data from the cache
+        data = Gxapi.with_error_handling do
+          # handle caching
+          self.list_experiments_from_cache
+        end
+        # turn into Gxapi::Ostructs
+        (data || []).collect{|data| Ostruct.new(data)}
+      end
+    end
+
+    #
+    # get a variant for an experiment
+    #
+    # @param experiment_name [String]
+    #
+    # @return [Gxapi::Ostruct]
+    def get_variant(experiment_name)
+      # pull in an experiment
+      experiment = self.get_experiment(experiment_name)
+
+      if self.run_experiment?(experiment)
+        # select variant for the experiment
+        variant = self.select_variant(experiment)
+        # return if it it's present
+        return variant if variant.present?
+      end
+      # return blank value if we don't have an experiment or don't get
+      # a valid value
+      return Ostruct.new(
+        name: "default",
+        index: -1,
+        experiment_id: nil
+      )
+    end
+
+    #
+    # reset and return a list of all experiments
+    #
+    # @return Array [Gxapi::Ostruct]
+    def reload_experiments
+      Gxapi.cache.delete(CACHE_KEY)
+      self.get_experiments
+    end
+
+    protected
+
+    #
+    # Api definition for analytics api
+    #
+    # @return [Google::APIClient::API] Discovered Analytics endpoint
+    def analytics
+      @analytics ||= self.client.discovered_api('analytics', 'v3')
+    end
+
+
+    #
+    # Discovered definition of Analytics Experiments
+    #
+    # @return [Google::APIClient::API] Discovered Analytics endpoint
+    def analytics_experiments
+      self.analytics.management.experiments
+    end
+
+    #
+    # Accessor for Google Analytics config
+    #
+    # @return [Ostruct] Configuration
+    def config
+      Gxapi.config.google_analytics
+    end
+
+    #
+    # google api client
+    #
+    # @return [Google::APIClient]
+    def client
+      @client ||= begin
+        client = Google::APIClient.new
+        # key stuff is hardcoded for now
+        key = Google::APIClient::KeyUtils.load_from_pkcs12(
+          Gxapi.config.google.private_key_path, 'notasecret'
+        )
+        client.authorization = Signet::OAuth2::Client.new(
+          token_credential_uri: 'https://accounts.google.com/o/oauth2/token',
+          audience: 'https://accounts.google.com/o/oauth2/token',
+          scope: 'https://www.googleapis.com/auth/analytics.readonly',
+          issuer: Gxapi.config.google.email,
+          signing_key: key
+        )
+        client.authorization.fetch_access_token!
+        client
+      end
+    end
+
+    #
+    # List all experiments for our account
+    #
+    # @return [Array<Gxapi::Ostruct>] Collection of Experiment data
+    # retrieved from Google's API
+    def list_experiments
+      response =  self.client.execute({
+        api_method: self.analytics_experiments.list,
+        parameters: {
+          accountId: self.config.account_id.to_s,
+          profileId: self.config.profile_id.to_s,
+          webPropertyId: self.config.web_property_id
+        }
+      })
+      response.data.items.collect(&:to_hash)
+    end
+
+    #
+    # List all experiments for our account, fetching from cache first
+    #
+    # @return [Array<Gxapi::Ostruct>] Collection of Experiment data from
+    # our cache or Google's API
+    def list_experiments_from_cache
+      Gxapi.cache.fetch(CACHE_KEY) do
+        self.list_experiments
+      end
+    end
+
+    #
+    # should we run this experiment under the current conditions?
+    #
+    # @return [Boolean] should_run
+    def run_experiment?(experiment)
+      # a blank experiment can't run
+      return false if experiment.nil?
+
+      # get a random value - a 100% coverage is represented
+      # as 1.0, so Kernel.rand works for us as its max is
+      # 1.0
+      return experiment.traffic_coverage >= Kernel.rand
+    end
+
+    #
+    # Select a variant from a given experiment
+    #
+    # @param  experiment [Ostruct] The experiment to choose for
+    #
+    # @return [Ostruct, nil] The selected variant or nil if none is
+    # selected
+    def select_variant(experiment)
+      # starts off at 0
+      accum = 0.0
+      sample = Kernel.rand
+
+      # go through our experiments and return the variation that matches
+      # our random value
+      experiment.variations.each_with_index do |variation, i|
+
+        # we want to record the index in the array for this variation
+        variation.index = i
+        variation.experiment_id = experiment.id
+
+        # add the variation's weight to accum
+        accum += variation.weight
+
+        # return the variation if accum is more than our random value
+        if sample <= accum
+          return variation
+        end
+      end
+      # default to nil
+      return nil
+    end
+
+  end
+end

data/lib/gxapi/ostruct.rb

@@ -0,0 +1,86 @@
+module Gxapi
+  class Ostruct
+    # recursive open struct
+    def initialize(hash)
+
+      @hash = {}
+
+      self.send(:extend, self.generated_methods)
+      hash.each_pair do |key, val|
+        # set the key to an underscored verison of itself
+        key = self.underscore(key)
+        self.define_accessors(key)
+        self.send("#{key}=", self.convert_value_to_ostruct(val))
+      end
+    end
+
+    def to_hash
+      ret = {}
+      @hash.dup.each_pair do |key, val|
+        ret[key] = self.convert_value_from_ostruct(val)
+      end
+      ret
+    end
+
+    protected
+    # convert a value to a Ostruct (where necessary)
+    def convert_value_to_ostruct(data)
+      case data
+      when Hash
+        self.class.new(data)
+      when Array
+        data.collect{|val| self.convert_value_to_ostruct(val)}
+      else
+        data
+      end
+    end
+
+
+    def convert_value_from_ostruct(data)
+      case data
+      when Ostruct
+        data.to_hash
+      when Array
+        data.collect{|val| self.convert_value_from_ostruct(data)}
+      else
+        data
+      end
+    end
+
+    # define accessors for an attribute
+    def define_accessors(field)
+      # add the generated method
+      self.generated_methods.module_eval do
+        define_method(field) do
+          @hash[field]
+        end
+        define_method("#{field}=") do |val|
+          @hash[field] = val
+        end
+      end
+    end
+
+    # module to hold generated methods
+    def generated_methods
+      @generated_methods ||= Module.new
+    end
+
+    # dynamically define getter and setter when an unknown setter is called
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /=$/
+        self.define_accessors(meth.to_s.gsub(/=$/,''))
+        return self.send(meth, *args, &block)
+      end
+      super
+    end
+
+    # take a string an convert it from
+    # camelCase to under_scored
+    def underscore(string)
+      string = string.to_s
+      string = string[0].downcase + string[1..-1].gsub(/([A-Z])/,'_\1')
+      string.downcase
+    end
+
+  end
+end

data/lib/gxapi/version.rb

@@ -0,0 +1,3 @@
+module Gxapi
+  VERSION = '0.0.2'
+end

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.