asana2flowdock 1.0.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/plugins/blacklist_security.rb

@@ -0,0 +1,93 @@
+module Sequel
+  module Plugins
+    # The blacklist_security plugin contains blacklist-based support for
+    # mass assignment, specifying which columns to not allow mass assignment for,
+    # implicitly allowing mass assignment for columns not listed.  This is only
+    # for backwards compatibility, it should not be used by new code.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support the blacklist security features. 
+    #   Sequel::Model.plugin :blacklist_security
+    #
+    #   # Make the Album class support the blacklist security features.
+    #   Album.plugin :blacklist_security
+    module BlacklistSecurity
+      module ClassMethods
+        # Which columns are specifically restricted in a call to set/update/new/etc.
+        # (default: not set).  Some columns are restricted regardless of
+        # this setting, such as the primary key column and columns in Model::RESTRICTED_SETTER_METHODS.
+        attr_reader :restricted_columns
+  
+        # Set the columns to restrict when using mass assignment (e.g. +set+).  Using this means that
+        # attempts to call setter methods for the columns listed here will cause an
+        # exception or be silently skipped (based on the +strict_param_setting+ setting).
+        # If you have any virtual setter methods (methods that end in =) that you
+        # want not to be used during mass assignment, they need to be listed here as well (without the =).
+        #
+        # It's generally a bad idea to rely on a blacklist approach for security.  Using a whitelist
+        # approach such as set_allowed_columns or the instance level set_only or set_fields methods
+        # is usually a better choice.  So use of this method is generally a bad idea.
+        #
+        #   Artist.set_restricted_columns(:records_sold)
+        #   Artist.set(:name=>'Bob', :hometown=>'Sactown') # No Error
+        #   Artist.set(:name=>'Bob', :records_sold=>30000) # Error
+        def set_restricted_columns(*cols)
+          clear_setter_methods_cache
+          @restricted_columns = cols
+        end
+
+        private
+
+        # If allowed_columns is not set but restricted_columns is, remove the
+        # restricted_columns.
+        def get_setter_methods
+          meths = super
+          if !allowed_columns && restricted_columns
+            meths -= restricted_columns.map{|x| "#{x}="}
+          end
+          meths
+        end
+      end
+
+      module InstanceMethods
+        # Special array subclass used for marking methods to be removed.
+        class ExceptionList < Array
+        end
+
+        # Set all values using the entries in the hash, except for the keys
+        # given in except.  You should probably use +set_fields+ or +set_only+
+        # instead of this method, as blacklist approaches to security are a bad idea.
+        #
+        #   artist.set_except({:name=>'Jim'}, :hometown)
+        #   artist.name # => 'Jim'
+        def set_except(hash, *except)
+          set_restricted(hash, ExceptionList.new(except.flatten))
+        end
+    
+        # Update all values using the entries in the hash, except for the keys
+        # given in except.  You should probably use +update_fields+ or +update_only+
+        # instead of this method, as blacklist approaches to security are a bad idea.
+        #
+        #   artist.update_except({:name=>'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
+        def update_except(hash, *except)
+          update_restricted(hash, ExceptionList.new(except.flatten))
+        end
+
+        private
+
+        # If set_except or update_except was used, remove the related methods from the list.
+        def setter_methods(type)
+          if type.is_a?(ExceptionList)
+            meths = super(:all)
+            meths -= Array(primary_key).map{|x| "#{x}="} if primary_key && model.restrict_primary_key?
+            meths -= type.map{|x| "#{x}="}
+            meths
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/plugins/boolean_readers.rb

@@ -0,0 +1,56 @@
+module Sequel
+  module Plugins
+    # The BooleanReaders plugin allows for the creation of attribute? methods
+    # for boolean columns, which provides a nicer API.  By default, the accessors
+    # are created for all columns of type :boolean.  However, you can provide a
+    # block to the plugin to change the criteria used to determine if a
+    # column is boolean.  The block is yielded with the column symbol for each
+    # column in the models dataset.
+    #
+    # Usage:
+    #
+    #   # Add boolean attribute? methods for all columns of type :boolean
+    #   # in all model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :boolean_readers
+    #
+    #   # Add boolean readers for all tinyint columns in the Album class
+    #   Album.plugin(:boolean_readers){|c| db_schema[c][:db_type] =~ /\Atinyint/}
+    #
+    #   # Add a boolean reader for a specific columns in the Artist class
+    #   Artist.plugin(:boolean_readers){|c| [:column1, :column2, :column3].include?(c)}
+    module BooleanReaders
+      # Default proc for determining if given column is a boolean, which
+      # just checks that the :type is boolean.
+      DEFAULT_BOOLEAN_ATTRIBUTE_PROC = lambda{|c| s = db_schema[c] and s[:type] == :boolean}
+
+      # Add the boolean_attribute? class method to the model, and create
+      # attribute? boolean reader methods for the class's columns if the class has a dataset.
+      def self.configure(model, &block)
+        model.instance_eval do
+          (class << self; self; end).send(:define_method, :boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
+          send(:create_boolean_readers) if @dataset
+        end
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :create_boolean_readers)
+
+        private
+
+        # Add a attribute? method for the column to a module included in the class.
+        def create_boolean_reader(column)
+          overridable_methods_module.module_eval do
+            define_method("#{column}?"){model.db.typecast_value(:boolean, send(column))}
+          end
+        end
+
+        # Add attribute? methods for all of the boolean attributes for this model.
+        def create_boolean_readers
+          im = instance_methods.collect{|x| x.to_s}
+          cs = columns rescue return
+          cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/plugins/caching.rb

@@ -0,0 +1,153 @@
+module Sequel
+  module Plugins
+    # Sequel's built-in caching plugin supports caching to any object that
+    # implements the Ruby-Memcache API (or memcached API with the :ignore_exceptions
+    # option):
+    #
+    #    cache_store.set(key, obj, time) # Associate the obj with the given key
+    #                                    # in the cache for the time (specified
+    #                                    # in seconds).
+    #    cache_store.get(key) # => obj   # Returns object set with same key.
+    #    cache_store.get(key2) # => nil  # nil returned if there isn't an object
+    #                                    # currently in the cache with that key.
+    #    cache_store.delete(key)         # Remove key from cache
+    #
+    # If the :ignore_exceptions option is true, exceptions raised by cache_store.get
+    # are ignored and nil is returned instead.  The memcached API is to
+    # raise an exception for a missing record, so if you use memcached, you will
+    # want to use this option.
+    #
+    # Note that only Model.[] method calls with a primary key argument are cached
+    # using this plugin.
+    # 
+    # Usage:
+    #
+    #   # Make all subclasses use the same cache (called before loading subclasses)
+    #   # using the Ruby-Memcache API, with the cache stored in the CACHE constant
+    #   Sequel::Model.plugin :caching, CACHE
+    #
+    #   # Make the Album class use the cache with a 30 minute time-to-live
+    #   Album.plugin :caching, CACHE, :ttl=>1800
+    #
+    #   # Make the Artist class use a cache with the memcached protocol
+    #   Artist.plugin :caching, MEMCACHED_CACHE, :ignore_exceptions=>true
+    module Caching
+      # Set the cache_store and cache_ttl attributes for the given model.
+      # If the :ttl option is not given, 3600 seconds is the default.
+      def self.configure(model, store, opts=OPTS)
+        model.instance_eval do
+          @cache_store = store
+          @cache_ttl = opts[:ttl] || 3600
+          @cache_ignore_exceptions = opts[:ignore_exceptions]
+        end
+      end
+
+      module ClassMethods
+        # If true, ignores exceptions when gettings cached records (the memcached API).
+        attr_reader :cache_ignore_exceptions
+        
+        # The cache store object for the model, which should implement the
+        # Ruby-Memcache (or memcached) API
+        attr_reader :cache_store
+        
+        # The time to live for the cache store, in seconds.
+        attr_reader :cache_ttl
+
+        # Delete the cached object with the given primary key.
+        def cache_delete_pk(pk)
+          cache_delete(cache_key(pk))
+        end
+
+        # Return the cached object with the given primary key,
+        # or nil if no such object is in the cache.
+        def cache_get_pk(pk)
+          cache_get(cache_key(pk))
+        end
+
+        # Returns the prefix used to namespace this class in the cache.
+        def cache_key_prefix
+          "#{self}"
+        end
+
+        # Return a key string for the given primary key.
+        def cache_key(pk)
+          raise(Error, 'no primary key for this record') unless pk.is_a?(Array) ? pk.all? : pk
+          "#{cache_key_prefix}:#{Array(pk).join(',')}"
+        end
+        
+        Plugins.inherited_instance_variables(self, :@cache_store=>nil, :@cache_ttl=>nil, :@cache_ignore_exceptions=>nil)
+
+        # Set the time to live for the cache store, in seconds (default is 3600, # so 1 hour).
+        def set_cache_ttl(ttl)
+          @cache_ttl = ttl
+        end
+        
+        private
+    
+        # Delete the entry with the matching key from the cache
+        def cache_delete(ck)
+          if @cache_ignore_exceptions
+            @cache_store.delete(ck) rescue nil
+          else
+            @cache_store.delete(ck)
+          end
+          nil
+        end
+        
+        # Returned the cached object, or nil if the object was not
+        # in the cached
+        def cache_get(ck)
+          if @cache_ignore_exceptions
+            @cache_store.get(ck) rescue nil
+          else
+            @cache_store.get(ck)
+          end
+        end
+    
+        # Set the object in the cache_store with the given key for cache_ttl seconds.
+        def cache_set(ck, obj)
+          @cache_store.set(ck, obj, @cache_ttl)
+        end
+        
+        # Check the cache before a database lookup unless a hash is supplied.
+        def primary_key_lookup(pk)
+          ck = cache_key(pk)
+          unless obj = cache_get(ck)
+            if obj = super(pk)
+              cache_set(ck, obj)
+            end
+          end 
+          obj
+        end
+      end
+
+      module InstanceMethods
+        # Remove the object from the cache when updating
+        def before_update
+          cache_delete
+          super
+        end
+
+        # Return a key unique to the underlying record for caching, based on the
+        # primary key value(s) for the object.  If the model does not have a primary
+        # key, raise an Error.
+        def cache_key
+          model.cache_key(pk)
+        end
+    
+        # Remove the object from the cache when deleting
+        def delete
+          cache_delete
+          super
+        end
+
+        private
+    
+        # Delete this object from the cache
+        def cache_delete
+          model.cache_delete_pk(pk)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/plugins/class_table_inheritance.rb

@@ -0,0 +1,292 @@
+module Sequel
+  module Plugins
+    # The class_table_inheritance plugin allows you to model inheritance in the
+    # database using a table per model class in the hierarchy, with only columns
+    # unique to that model class (or subclass hierarchy) being stored in the related
+    # table.  For example, with this hierarchy:
+    #
+    #       Employee
+    #      /        \ 
+    #   Staff     Manager
+    #                |
+    #            Executive
+    #
+    # the following database schema may be used (table - columns):
+    #
+    # employees :: id, name, kind
+    # staff :: id, manager_id
+    # managers :: id, num_staff
+    # executives :: id, num_managers
+    #
+    # The class_table_inheritance plugin assumes that the main table
+    # (e.g. employees) has a primary key field (usually autoincrementing),
+    # and all other tables have a foreign key of the same name that points
+    # to the same key in their superclass's table.  For example:
+    #
+    # employees.id :: primary key, autoincrementing
+    # staff.id :: foreign key referencing employees(id)
+    # managers.id :: foreign key referencing employees(id)
+    # executives.id :: foreign key referencing managers(id)
+    #
+    # When using the class_table_inheritance plugin, subclasses use joined 
+    # datasets:
+    #
+    #   Employee.dataset.sql
+    #   # SELECT employees.id, employees.name, employees.kind
+    #   # FROM employees
+    #
+    #   Manager.dataset.sql
+    #   # SELECT employees.id, employees.name, employees.kind, managers.num_staff
+    #   # FROM employees
+    #   # JOIN managers ON (managers.id = employees.id)
+    #
+    #   Executive.dataset.sql
+    #   # SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers
+    #   # FROM employees
+    #   # JOIN managers ON (managers.id = employees.id)
+    #   # JOIN executives ON (executives.id = managers.id)
+    #
+    # This allows Executive.all to return instances with all attributes
+    # loaded.  The plugin overrides the deleting, inserting, and updating
+    # in the model to work with multiple tables, by handling each table
+    # individually.
+    #
+    # This plugin allows the use of a :key option when loading to mark
+    # a column holding a class name.  This allows methods on the
+    # superclass to return instances of specific subclasses.
+    # This plugin also requires the lazy_attributes plugin and uses it to
+    # return subclass specific attributes that would not be loaded
+    # when calling superclass methods (since those wouldn't join
+    # to the subclass tables).  For example:
+    #
+    #   a = Employee.all # [<#Staff>, <#Manager>, <#Executive>]
+    #   a.first.values # {:id=>1, name=>'S', :kind=>'Staff'}
+    #   a.first.manager_id # Loads the manager_id attribute from the database
+    #
+    # If you want to get all columns in a subclass instance after loading
+    # via the superclass, call Model#refresh.
+    #
+    #   a = Employee.first
+    #   a.values # {:id=>1, name=>'S', :kind=>'Executive'}
+    #   a.refresh.values # {:id=>1, name=>'S', :kind=>'Executive', :num_staff=>4, :num_managers=>2}
+    # 
+    # Usage:
+    #
+    #   # Set up class table inheritance in the parent class
+    #   # (Not in the subclasses)
+    #   class Employee < Sequel::Model
+    #     plugin :class_table_inheritance
+    #   end
+    #
+    #   # Have subclasses inherit from the appropriate class
+    #   class Staff < Employee; end
+    #   class Manager < Employee; end
+    #   class Executive < Manager; end
+    #
+    #   # You can also set options when loading the plugin:
+    #   # :kind :: column to hold the class name
+    #   # :table_map :: map of class name symbols to table name symbols
+    #   # :model_map :: map of column values to class name symbols
+    #   Employee.plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff},
+    #     :model_map=>{1=>:Employee, 2=>:Manager, 3=>:Executive, 4=>:Staff}
+    module ClassTableInheritance
+      # The class_table_inheritance plugin requires the lazy_attributes plugin
+      # to handle lazily-loaded attributes for subclass instances returned
+      # by superclass methods.
+      def self.apply(model, opts=OPTS)
+        model.plugin :lazy_attributes
+      end
+      
+      # Initialize the per-model data structures and set the dataset's row_proc
+      # to check for the :key option column for the type of class when loading objects.
+      # Options:
+      # :key :: The column symbol holding the name of the model class this
+      #         is an instance of.  Necessary if you want to call model methods
+      #         using the superclass, but have them return subclass instances.
+      # :table_map :: Hash with class name symbol keys and table name symbol
+      #               values.  Necessary if the implicit table name for the model class
+      #               does not match the database table name
+      # :model_map :: Hash with keys being values of the cti_key column, and values
+      #               being class name strings or symbols.  Used if you don't want to
+      #               store class names in the database.  If you use this option, you
+      #               are responsible for setting the values of the cti_key column
+      #               manually (usually in a before_create hook).
+      def self.configure(model, opts=OPTS)
+        model.instance_eval do
+          @cti_base_model = self
+          @cti_key = opts[:key] 
+          @cti_tables = [table_name]
+          @cti_columns = {table_name=>columns}
+          @cti_table_map = opts[:table_map] || {}
+          @cti_model_map = opts[:model_map]
+          set_dataset_cti_row_proc
+          set_dataset(dataset.select(*columns.map{|c| Sequel.qualify(table_name, Sequel.identifier(c))}))
+        end
+      end
+
+      module ClassMethods
+        # The parent/root/base model for this class table inheritance hierarchy.
+        # This is the only model in the hierarchy that load the
+        # class_table_inheritance plugin.
+        attr_reader :cti_base_model
+        
+        # Hash with table name symbol keys and arrays of column symbol values,
+        # giving the columns to update in each backing database table.
+        attr_reader :cti_columns
+        
+        # The column containing the class name as a string.  Used to
+        # return instances of subclasses when calling the superclass's
+        # load method.
+        attr_reader :cti_key
+        
+        # A hash with keys being values of the cti_key column, and values
+        # being class name strings or symbols.  Used if you don't want to
+        # store class names in the database.
+        attr_reader :cti_model_map
+        
+        # An array of table symbols that back this model.  The first is
+        # cti_base_model table symbol, and the last is the current model
+        # table symbol.
+        attr_reader :cti_tables
+        
+        # A hash with class name symbol keys and table name symbol values.
+        # Specified with the :table_map option to the plugin, and used if
+        # the implicit naming is incorrect.
+        attr_reader :cti_table_map
+        
+        # Add the appropriate data structures to the subclass.  Does not
+        # allow anonymous subclasses to be created, since they would not
+        # be mappable to a table.
+        def inherited(subclass)
+          cc = cti_columns
+          ck = cti_key
+          ct = cti_tables.dup
+          ctm = cti_table_map.dup
+          cbm = cti_base_model
+          cmm = cti_model_map
+          pk = primary_key
+          ds = dataset
+          table = nil
+          columns = nil
+          subclass.instance_eval do
+            raise(Error, "cannot create anonymous subclass for model class using class_table_inheritance") if !(n = name) || n.empty?
+            table = ctm[n.to_sym] || implicit_table_name
+            columns = db.from(table).columns
+            @cti_key = ck 
+            @cti_tables = ct + [table]
+            @cti_columns = cc.merge(table=>columns)
+            @cti_table_map = ctm
+            @cti_base_model = cbm
+            @cti_model_map = cmm
+            # Need to set dataset and columns before calling super so that
+            # the main column accessor module is included in the class before any
+            # plugin accessor modules (such as the lazy attributes accessor module).
+            set_dataset(ds.join(table, pk=>pk).select_append(*(columns - [primary_key]).map{|c| Sequel.qualify(table, Sequel.identifier(c))}))
+            set_columns(self.columns)
+          end
+          super
+          subclass.instance_eval do
+            set_dataset_cti_row_proc
+            (columns - [cbm.primary_key]).each{|a| define_lazy_attribute_getter(a, :dataset=>dataset, :table=>table)}
+            cti_tables.reverse.each do |t|
+              db.schema(t).each{|k,v| db_schema[k] = v}
+            end
+          end
+        end
+        
+        # The primary key in the parent/base/root model, which should have a
+        # foreign key with the same name referencing it in each model subclass.
+        def primary_key
+          return super if self == cti_base_model
+          cti_base_model.primary_key
+        end
+        
+        # The table name for the current model class's main table (not used
+        # by any superclasses).
+        def table_name
+          self == cti_base_model ? super : cti_tables.last
+        end
+
+        private
+
+        # If calling set_dataset manually, make sure to set the dataset
+        # row proc to one that handles inheritance correctly.
+        def set_dataset_row_proc(ds)
+          ds.row_proc = @dataset.row_proc if @dataset
+        end
+
+        # Set the row_proc for the model's dataset appropriately
+        # based on the cti key and model map.
+        def set_dataset_cti_row_proc
+          m = method(:constantize)
+          dataset.row_proc = if ck = cti_key
+            if model_map = cti_model_map
+              lambda do |r|
+                mod = if name = model_map[r[ck]]
+                  m.call(name)
+                else
+                  self
+                end
+                mod.call(r)
+              end
+            else
+              lambda{|r| (m.call(r[ck]) rescue self).call(r)}
+            end
+          else
+            self
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Delete the row from all backing tables, starting from the
+        # most recent table and going through all superclasses.
+        def delete
+          raise Sequel::Error, "can't delete frozen object" if frozen?
+          m = model
+          m.cti_tables.reverse.each do |table|
+            m.db.from(table).filter(m.primary_key=>pk).delete
+          end
+          self
+        end
+        
+        private
+        
+        # Set the cti_key column to the name of the model.
+        def _before_validation
+          if new? && model.cti_key && !model.cti_model_map
+            send("#{model.cti_key}=", model.name.to_s)
+          end
+          super
+        end
+        
+        # Insert rows into all backing tables, using the columns
+        # in each table.  
+        def _insert
+          return super if model == model.cti_base_model
+          iid = @values[primary_key] 
+          m = model
+          m.cti_tables.each do |table|
+            h = {}
+            h[m.primary_key] ||= iid if iid
+            m.cti_columns[table].each{|c| h[c] = @values[c] if @values.include?(c)}
+            nid = m.db.from(table).insert(h)
+            iid ||= nid
+          end
+          @values[primary_key] = iid
+        end
+        
+        # Update rows in all backing tables, using the columns in each table.
+        def _update(columns)
+          pkh = pk_hash
+          m = model
+          m.cti_tables.each do |table|
+            h = {}
+            m.cti_columns[table].each{|c| h[c] = columns[c] if columns.include?(c)}
+            m.db.from(table).filter(pkh).update(h) unless h.empty?
+          end
+        end
+      end
+    end
+  end
+end