SYMBOL INDEX (309 symbols across 48 files)

FILE: app/controllers/trebuchet_rails/features_controller.rb
  type TrebuchetRails (line 1) | module TrebuchetRails
    class FeaturesController (line 3) | class FeaturesController < ApplicationController
      method index (line 14) | def index
      method timeline (line 27) | def timeline
      method control_access (line 52) | def control_access
      method get_time_zone (line 65) | def get_time_zone

FILE: app/helpers/trebuchet_helper.rb
  type TrebuchetHelper (line 1) | module TrebuchetHelper
    function feature (line 3) | def feature(feature)
    function strategy (line 8) | def strategy(strategy)
    function trebuchet_css (line 18) | def trebuchet_css

FILE: lib/trebuchet.rb
  class Trebuchet (line 3) | class Trebuchet
    method backend (line 18) | def backend
    method set_backend (line 23) | def set_backend(backend_type, *args)
    method initialize_logs (line 40) | def initialize_logs
    method log (line 44) | def log(feature_name, result)
    method logs (line 49) | def logs
    method current= (line 53) | def current=(other)
    method current (line 57) | def current
    method reset_current! (line 62) | def reset_current!
    method thread_local_key (line 66) | def thread_local_key
    method state (line 75) | def state
    method state= (line 83) | def state=(new_state)
    method threadsafe_state? (line 91) | def threadsafe_state?
    method aim (line 96) | def self.aim(feature_name, *args)
    method dismantle (line 100) | def self.dismantle(feature_name)
    method dismantle_stubs (line 104) | def self.dismantle_stubs
    method define_strategy (line 108) | def self.define_strategy(name, &block)
    method define_request_aware_strategy (line 112) | def self.define_request_aware_strategy(name, &block)
    method visitor_id= (line 116) | def self.visitor_id=(id_or_proc)
    method use_with_rails! (line 126) | def self.use_with_rails!
    method feature (line 132) | def self.feature(name)
    method initialize (line 136) | def initialize(current_user, request = nil)
    method launch (line 142) | def launch(feature, &block)
    method launch? (line 148) | def launch?(feature)
    method handle_exception (line 163) | def handle_exception(exception, feature = nil)
    method export (line 171) | def self.export
    method history (line 179) | def self.history(include_archived = false)

FILE: lib/trebuchet/action_controller.rb
  type Trebuchet::ActionController (line 3) | module Trebuchet::ActionController
    function included (line 5) | def self.included(base)
    function trebuchet (line 12) | def trebuchet

FILE: lib/trebuchet/action_controller_filter.rb
  class Trebuchet::ActionControllerFilter (line 1) | class Trebuchet::ActionControllerFilter
    method before (line 3) | def self.before(controller)
    method after (line 15) | def self.after(controller)

FILE: lib/trebuchet/backend.rb
  type Trebuchet::Backend (line 1) | module Trebuchet::Backend
    function lookup (line 3) | def self.lookup(name)

FILE: lib/trebuchet/backend/disabled.rb
  class Trebuchet::Backend::Disabled (line 4) | class Trebuchet::Backend::Disabled
    method initialize (line 6) | def initialize(*args)
    method get_strategy (line 9) | def get_strategy(feature_name)
    method set_strategy (line 13) | def set_strategy(feature, strategy, options = nil)
    method append_strategy (line 17) | def append_strategy(feature, strategy, options = nil)
    method get_feature_names (line 21) | def get_feature_names

FILE: lib/trebuchet/backend/memcached.rb
  class Trebuchet::Backend::Memcached (line 3) | class Trebuchet::Backend::Memcached
    method initialize (line 7) | def initialize(*args)
    method get_strategy (line 12) | def get_strategy(feature_name)
    method set_strategy (line 16) | def set_strategy(feature, strategy, options = nil)
    method append_strategy (line 20) | def append_strategy(feature, strategy, options = nil)
    method get_feature_names (line 24) | def get_feature_names
    method key (line 30) | def key(feature_name)

FILE: lib/trebuchet/backend/memory.rb
  class Trebuchet::Backend::Memory (line 1) | class Trebuchet::Backend::Memory
    method initialize (line 3) | def initialize(*args)
    method get_strategy (line 8) | def get_strategy(feature_name)
    method set_strategy (line 12) | def set_strategy(feature, strategy, options = nil)
    method append_strategy (line 17) | def append_strategy(feature, strategy, options = nil)
    method remove_strategy (line 28) | def remove_strategy(feature)
    method get_feature_names (line 32) | def get_feature_names
    method remove_feature (line 36) | def remove_feature(feature)
    method get_archived_feature_names (line 42) | def get_archived_feature_names

FILE: lib/trebuchet/backend/redis.rb
  class Trebuchet::Backend::Redis (line 4) | class Trebuchet::Backend::Redis
    method initialize (line 8) | def initialize(*args)
    method get_strategy (line 27) | def get_strategy(feature_name)
    method unpack_strategy (line 32) | def unpack_strategy(options)
    method set_strategy (line 48) | def set_strategy(feature_name, strategy, options = nil)
    method append_strategy (line 54) | def append_strategy(feature_name, strategy, options = nil)
    method remove_strategy (line 62) | def remove_strategy(feature_name)
    method get_feature_names (line 67) | def get_feature_names
    method get_archived_feature_names (line 71) | def get_archived_feature_names
    method remove_feature (line 75) | def remove_feature(feature_name)
    method store_history (line 82) | def store_history(feature_name)
    method get_history (line 89) | def get_history(feature_name)
    method get_all_history (line 98) | def get_all_history(include_archived = false)
    method update_sentinel (line 120) | def update_sentinel
    method get_sentinel (line 124) | def get_sentinel
    method archived_feature_names_key (line 130) | def archived_feature_names_key
    method feature_names_key (line 134) | def feature_names_key
    method feature_key (line 138) | def feature_key(feature_name)
    method feature_history_key (line 142) | def feature_history_key(feature_name, timestamp = nil)
    method sentinel_key (line 148) | def sentinel_key

FILE: lib/trebuchet/backend/redis_cached.rb
  class Trebuchet::Backend::RedisCached (line 3) | class Trebuchet::Backend::RedisCached < Trebuchet::Backend::Redis
    method get_strategy (line 7) | def get_strategy(feature_name)
    method append_strategy (line 19) | def append_strategy(feature_name, strategy, options = nil)
    method cache_strategy (line 26) | def cache_strategy(feature_name, strategy)
    method cached_strategies (line 30) | def cached_strategies
    method cache_cleared_at (line 34) | def cache_cleared_at
    method clear_cached_strategies (line 38) | def clear_cached_strategies
    method refresh (line 43) | def refresh

FILE: lib/trebuchet/backend/redis_hammerspaced.rb
  class Trebuchet::Backend::RedisHammerspaced (line 4) | class Trebuchet::Backend::RedisHammerspaced < Trebuchet::Backend::Redis
    method initialize (line 13) | def initialize(*args)
    method get_strategy (line 19) | def get_strategy(feature_name)
    method get_strategy_hammerspace (line 29) | def get_strategy_hammerspace(feature_name)
    method unpack_strategy_hammerspace (line 42) | def unpack_strategy_hammerspace(options)
    method get_feature_names (line 59) | def get_feature_names
    method append_strategy (line 65) | def append_strategy(feature_name, strategy, options = nil)
    method cache_strategy (line 72) | def cache_strategy(feature_name, strategy)
    method cached_strategies (line 76) | def cached_strategies
    method clear_cached_strategies (line 80) | def clear_cached_strategies
    method refresh (line 84) | def refresh
    method update_hammerspace (line 93) | def update_hammerspace(forced = false)
    method generate_hammerspace_hash (line 117) | def generate_hammerspace_hash(feature_names, features, last_updated)

FILE: lib/trebuchet/error.rb
  class Trebuchet::Error (line 1) | class Trebuchet::Error < StandardError ; end
  class Trebuchet::BackendInitializationError (line 2) | class Trebuchet::BackendInitializationError < Trebuchet::Error ; end
  class Trebuchet::BackendError (line 3) | class Trebuchet::BackendError < Trebuchet::Error ; end

FILE: lib/trebuchet/feature.rb
  class Trebuchet::Feature (line 3) | class Trebuchet::Feature
    method initialize (line 11) | def initialize(name)
    method find (line 15) | def self.find(name)
    method reset (line 27) | def reset
    method all (line 31) | def self.all
    method dismantled (line 35) | def self.dismantled
    method exist? (line 39) | def self.exist?(name)
    method with_deprecated_strategies_enabled (line 46) | def self.with_deprecated_strategies_enabled(value=true, &block)
    method strategy (line 56) | def strategy
    method valid? (line 60) | def valid?
    method launch_at? (line 64) | def launch_at?(user, request = nil)
    method aim (line 70) | def aim(strategy_name, options = nil)
    method adjust (line 85) | def adjust(strategy_name, options = nil)
    method augment (line 91) | def augment(strategy_name, new_options)
    method dismantle (line 112) | def dismantle
    method add_comment (line 117) | def add_comment(comment)
    method expiration_date (line 125) | def expiration_date
    method set_expiration_date (line 131) | def set_expiration_date(expiration_date)
    method history (line 136) | def history
    method feature_id (line 143) | def feature_id
    method as_json (line 151) | def as_json(options = {})
    method to_s (line 155) | def to_s
    method inspect (line 160) | def inspect
    method export (line 164) | def export
    method chained? (line 170) | def chained?

FILE: lib/trebuchet/feature/stubbing.rb
  class Trebuchet (line 1) | class Trebuchet
    class Feature (line 2) | class Feature
      type Stubbing (line 3) | module Stubbing
        function stub (line 5) | def stub(state)
        function stubbed? (line 9) | def stubbed?
        function included (line 13) | def self.included(base)
        type ClassMethods (line 17) | module ClassMethods
          function dismantle_stubs (line 19) | def dismantle_stubs
          function stubbed_features (line 23) | def stubbed_features

FILE: lib/trebuchet/strategy.rb
  type Trebuchet::Strategy (line 3) | module Trebuchet::Strategy
    function for_feature (line 5) | def self.for_feature(feature)
    function find (line 15) | def self.find(*args)
    function name_class_map (line 41) | def self.name_class_map
    function deprecated_strategy_names (line 63) | def self.deprecated_strategy_names
    function class_for_name (line 70) | def self.class_for_name(name)
    function name_for_class (line 75) | def self.name_for_class(klass)
    type PerDenominationable (line 80) | module PerDenominationable
      function initialize (line 83) | def initialize(options)
      function set_range_from_options (line 88) | def set_range_from_options(options)
      function value_in_range? (line 101) | def value_in_range?(value)
      function to_s (line 107) | def to_s
      function export (line 111) | def export
    type Percentable (line 118) | module Percentable
      function set_range_from_options (line 124) | def set_range_from_options(options)
      function to_s (line 135) | def to_s
      function export (line 141) | def export
    type PercentableDeprecated (line 151) | module PercentableDeprecated
      function initialize (line 153) | def initialize(options)
      function set_range_from_options (line 158) | def set_range_from_options(options)
      function offset (line 177) | def offset
      function percentage (line 185) | def percentage
      function value_in_range? (line 192) | def value_in_range?(value)
      function offset_from (line 201) | def offset_from
      function offset_to (line 205) | def offset_to
      function to_s (line 209) | def to_s
      function export (line 224) | def export
    type Experimentable (line 234) | module Experimentable
      function initialize_experiment (line 238) | def initialize_experiment(options)
      function value_in_bucket? (line 245) | def value_in_bucket?(value)
      function valid? (line 253) | def valid?
      function type (line 259) | def type
      function as_json (line 263) | def as_json(options = {})
      function to_s (line 272) | def to_s
      function export (line 277) | def export
      function inspect (line 281) | def inspect

FILE: lib/trebuchet/strategy/base.rb
  class Trebuchet::Strategy::Base (line 3) | class Trebuchet::Strategy::Base
    method name (line 7) | def name
    method feature_id (line 11) | def feature_id
    method needs_user? (line 15) | def needs_user?
    method strategy_name (line 19) | def self.strategy_name
    method as_json (line 23) | def as_json(options = {})
    method inspect (line 33) | def inspect
    method export (line 37) | def export(options = nil)

FILE: lib/trebuchet/strategy/custom.rb
  class Trebuchet::Strategy::Custom (line 1) | class Trebuchet::Strategy::Custom < Trebuchet::Strategy::Base
    method initialize (line 7) | def initialize(name, options = nil)
    method launch_at? (line 13) | def launch_at?(user, request = nil)
    method define (line 17) | def self.define(name, block)
    method exists? (line 21) | def self.exists?(name)
    method needs_user? (line 25) | def needs_user?
    method as_json (line 35) | def as_json(options = {})
    method to_s (line 39) | def to_s
    method export (line 43) | def export

FILE: lib/trebuchet/strategy/custom_request_aware.rb
  class Trebuchet::Strategy::CustomRequestAware (line 1) | class Trebuchet::Strategy::CustomRequestAware < Trebuchet::Strategy::Custom
    method initialize (line 4) | def initialize(name, options = nil)
    method define (line 10) | def self.define(name, block)
    method exists? (line 14) | def self.exists?(name)
    method launch_at? (line 18) | def launch_at?(user, request = nil)
    method to_s (line 23) | def to_s

FILE: lib/trebuchet/strategy/default.rb
  class Trebuchet::Strategy::Default (line 4) | class Trebuchet::Strategy::Default < Trebuchet::Strategy::Base
    method initialize (line 7) | def initialize(options = nil)
    method name (line 11) | def name
    method launch_at? (line 15) | def launch_at?(user, request = nil)
    method needs_user? (line 19) | def needs_user?
    method to_s (line 23) | def to_s

FILE: lib/trebuchet/strategy/everyone.rb
  class Trebuchet::Strategy::Everyone (line 3) | class Trebuchet::Strategy::Everyone < Trebuchet::Strategy::Base
    method initialize (line 6) | def initialize(options = nil)
    method name (line 10) | def name
    method launch_at? (line 14) | def launch_at?(user, request = nil)
    method needs_user? (line 18) | def needs_user?
    method to_s (line 22) | def to_s

FILE: lib/trebuchet/strategy/experiment.rb
  class Trebuchet::Strategy::Experiment (line 3) | class Trebuchet::Strategy::Experiment < Trebuchet::Strategy::Base
    method initialize (line 7) | def initialize(options = {})
    method launch_at? (line 11) | def launch_at?(user, request = nil)

FILE: lib/trebuchet/strategy/hostname.rb
  class Trebuchet::Strategy::Hostname (line 1) | class Trebuchet::Strategy::Hostname < Trebuchet::Strategy::Base
    method initialize (line 5) | def initialize(hostnames)
    method launch_at? (line 13) | def launch_at?(user, request = nil)
    method needs_user? (line 18) | def needs_user?
    method to_s (line 22) | def to_s
    method export (line 26) | def export

FILE: lib/trebuchet/strategy/invalid.rb
  class Trebuchet::Strategy::Invalid (line 2) | class Trebuchet::Strategy::Invalid < Trebuchet::Strategy::Base
    method initialize (line 6) | def initialize(name, options = nil)
    method name (line 11) | def name
    method launch_at? (line 15) | def launch_at?(user, request = nil)
    method needs_user? (line 19) | def needs_user?
    method to_s (line 23) | def to_s

FILE: lib/trebuchet/strategy/logic_and.rb
  class Trebuchet::Strategy::LogicAnd (line 3) | class Trebuchet::Strategy::LogicAnd < Trebuchet::Strategy::LogicBase
    method launch_at? (line 5) | def launch_at?(user, request = nil)

FILE: lib/trebuchet/strategy/logic_base.rb
  class Trebuchet::Strategy::LogicBase (line 1) | class Trebuchet::Strategy::LogicBase < Trebuchet::Strategy::Base
    method initialize (line 6) | def initialize(options = {})
    method feature= (line 15) | def feature=(f)
    method launch_at? (line 20) | def launch_at?(user, request = nil)
    method needs_user? (line 24) | def needs_user?

FILE: lib/trebuchet/strategy/logic_not.rb
  class Trebuchet::Strategy::LogicNot (line 3) | class Trebuchet::Strategy::LogicNot < Trebuchet::Strategy::LogicBase
    method launch_at? (line 5) | def launch_at?(user, request = nil)

FILE: lib/trebuchet/strategy/logic_or.rb
  class Trebuchet::Strategy::LogicOr (line 3) | class Trebuchet::Strategy::LogicOr < Trebuchet::Strategy::LogicBase
    method launch_at? (line 5) | def launch_at?(user, request = nil)

FILE: lib/trebuchet/strategy/multiple.rb
  class Trebuchet::Strategy::Multiple (line 1) | class Trebuchet::Strategy::Multiple < Trebuchet::Strategy::Base
    method initialize (line 5) | def initialize(args)
    method feature= (line 13) | def feature=(f)
    method launch_at? (line 18) | def launch_at?(user, request = nil)
    method as_json (line 23) | def as_json(options = {})
    method needs_user? (line 27) | def needs_user?
    method export (line 33) | def export

FILE: lib/trebuchet/strategy/nobody.rb
  class Trebuchet::Strategy::Nobody (line 3) | class Trebuchet::Strategy::Nobody < Trebuchet::Strategy::Base
    method initialize (line 6) | def initialize(options = nil)
    method name (line 10) | def name
    method launch_at? (line 14) | def launch_at?(user, request = nil)
    method needs_user? (line 18) | def needs_user?
    method to_s (line 22) | def to_s

FILE: lib/trebuchet/strategy/per_denomination.rb
  class Trebuchet::Strategy::PerDenomination (line 1) | class Trebuchet::Strategy::PerDenomination < Trebuchet::Strategy::Base
    method set_range_from_options (line 4) | def set_range_from_options(options = {})
    method launch_at? (line 11) | def launch_at?(user, request = nil)

FILE: lib/trebuchet/strategy/percent.rb
  class Trebuchet::Strategy::Percent (line 1) | class Trebuchet::Strategy::Percent < Trebuchet::Strategy::Base
    method initialize (line 5) | def initialize(options)
    method launch_at? (line 9) | def launch_at?(user, request = nil)

FILE: lib/trebuchet/strategy/percent_deprecated.rb
  class Trebuchet::Strategy::PercentDeprecated (line 1) | class Trebuchet::Strategy::PercentDeprecated < Trebuchet::Strategy::Base
    method initialize (line 5) | def initialize(options)
    method launch_at? (line 9) | def launch_at?(user, request = nil)

FILE: lib/trebuchet/strategy/stub.rb
  class Trebuchet (line 1) | class Trebuchet
    type Strategy (line 2) | module Strategy
      class Stub (line 4) | class Stub < Trebuchet::Strategy::Base
        method initialize (line 7) | def initialize(state)
        method launch_at? (line 11) | def launch_at?(user, request = nil)
        method needs_user? (line 15) | def needs_user?
        method to_s (line 19) | def to_s
        method export (line 23) | def export

FILE: lib/trebuchet/strategy/user_id.rb
  class Trebuchet::Strategy::UserId (line 1) | class Trebuchet::Strategy::UserId < Trebuchet::Strategy::Base
    method initialize (line 5) | def initialize(user_ids)
    method launch_at? (line 10) | def launch_at?(user, request = nil)
    method to_s (line 14) | def to_s
    method export (line 18) | def export

FILE: lib/trebuchet/strategy/visitor_experiment.rb
  class Trebuchet::Strategy::VisitorExperiment (line 1) | class Trebuchet::Strategy::VisitorExperiment < Trebuchet::Strategy::Base
    method initialize (line 5) | def initialize(options = {})
    method launch_at? (line 9) | def launch_at?(user, request = nil)
    method needs_user? (line 19) | def needs_user?

FILE: lib/trebuchet/strategy/visitor_percent.rb
  class Trebuchet::Strategy::VisitorPercent (line 1) | class Trebuchet::Strategy::VisitorPercent < Trebuchet::Strategy::Base
    method initialize (line 5) | def initialize(options)
    method launch_at? (line 9) | def launch_at?(user, request = nil)
    method needs_user? (line 20) | def needs_user?

FILE: lib/trebuchet/strategy/visitor_percent_deprecated.rb
  class Trebuchet::Strategy::VisitorPercentDeprecated (line 1) | class Trebuchet::Strategy::VisitorPercentDeprecated < Trebuchet::Strateg...
    method initialize (line 5) | def initialize(options)
    method launch_at? (line 9) | def launch_at?(user, request = nil)
    method needs_user? (line 20) | def needs_user?

FILE: lib/trebuchet/version.rb
  class Trebuchet (line 1) | class Trebuchet

FILE: lib/trebuchet_rails/engine.rb
  type TrebuchetRails (line 5) | module TrebuchetRails
    class Engine (line 6) | class Engine < Rails::Engine

FILE: spec/feature_spec.rb
  function feature (line 5) | def feature
  function feature_names (line 9) | def feature_names
  function archived_feature_names (line 13) | def archived_feature_names

FILE: spec/percent_deprecated_strategy_spec.rb
  function should_only_launch_to_a_percentage_of_users (line 19) | def should_only_launch_to_a_percentage_of_users(feature_name)
  function offset_ids (line 60) | def offset_ids(ids, offset)

FILE: spec/redis_hammerspaced_spec.rb
  function uid (line 58) | def hammerspace.uid
  function close (line 62) | def hammerspace.close

FILE: spec/spec_helper.rb
  class Redis (line 9) | class Redis < MockRedis ; end
  function should_launch (line 26) | def should_launch(feature, users)
  function should_not_launch (line 30) | def should_not_launch(feature, users)
  function should_or_should_not_launch (line 34) | def should_or_should_not_launch(feature, users, be_true_or_false)
  function mock_request (line 41) | def mock_request(cookie = nil)

FILE: spec/trebuchet_spec.rb
  class BoomError (line 96) | class BoomError < StandardError ; end

FILE: spec/user.rb
  class User (line 1) | class User < Struct.new(:id, :role)
    method has_role? (line 3) | def has_role?(role)

FILE: spec/visitor_percent_deprecated_strategy_spec.rb
  function should_launch_test (line 38) | def should_launch_test(feature_name)

FILE: spec/visitor_percent_strategy_spec.rb
  function should_launch_test (line 30) | def should_launch_test(feature_name)