asana2flowdock 1.0.0 → 1.1.0

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

@@ -1,54 +0,0 @@
-module Sequel
-  module Plugins
-    # The error_splitter plugin automatically splits errors entries related to
-    # multiple columns to have separate error entries, one per column.  For example,
-    # a multiple column uniqueness entry:
-    #
-    #   validates_unique([:artist_id, :name])
-    #
-    # would by default result in errors entries such as:
-    #
-    #   {[:artist_id, :name]=>'is already taken'}
-    #
-    # This plugin transforms those errors into:
-    #
-    #   {:artist_id=>'is already taken', :name=>'is already taken'}
-    #
-    # The main reason to split errors is if you have a list of fields that you
-    # are checking for validation errors.  If you don't split the errors, then:
-    #
-    #   errors.on(:artist_id)
-    #
-    # would not return the uniqueness error.
-    # 
-    # Usage:
-    #
-    #   # Make all model subclass instances split errors (called before loading subclasses)
-    #   Sequel::Model.plugin :error_splitter
-    #
-    #   # Make the Album class split errors
-    #   Album.plugin :error_splitter
-    module ErrorSplitter
-      module InstanceMethods
-        # If the model instance is not valid, go through all of the errors entries.  For
-        # any that apply to multiple columns, remove them and add separate error entries,
-        # one per column.
-        def _valid?(*)
-          v = super
-          unless v
-            errors.keys.select{|k| k.is_a?(Array)}.each do |ks|
-              msgs = errors.delete(ks)
-              ks.each do |k|
-                msgs.each do |msg|
-                  errors.add(k, msg)
-                end
-              end
-            end
-          end
-          v
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,81 +0,0 @@
-if RUBY_VERSION >= '1.9.0'
-module Sequel
-  module Plugins
-    # The ForceEncoding plugin allows you force specific encodings for all
-    # strings that are used by the model.  When model instances are loaded
-    # from the database, all values in the hash that are strings are
-    # forced to the given encoding.  Whenever you update a model column
-    # attribute, the resulting value is forced to a given encoding if the
-    # value is a string.  There are two ways to specify the encoding.  You
-    # can either do so in the plugin call itself, or via the
-    # forced_encoding class accessor.
-    #
-    # Usage:
-    #
-    #   # Force all strings to be UTF8 encoded in a all model subclasses
-    #   # (called before loading subclasses)
-    #   Sequel::Model.plugin :force_encoding, 'UTF-8'
-    #
-    #   # Force the encoding for the Album model to UTF8
-    #   Album.plugin :force_encoding
-    #   Album.forced_encoding = 'UTF-8'
-    module ForceEncoding
-      # Set the forced_encoding based on the value given in the plugin call.
-      # Note that if a the plugin has been previously loaded, any previous
-      # forced encoding is overruled, even if no encoding is given when calling
-      # the plugin.
-      def self.configure(model, encoding=nil)
-        model.forced_encoding = encoding
-      end
-      
-      module ClassMethods
-        # The string encoding to force on a column string values
-        attr_accessor :forced_encoding
-        
-        Plugins.inherited_instance_variables(self, :@forced_encoding=>nil)
-
-        def call(values)
-          o = super
-          o.send(:force_hash_encoding, o.values)
-          o
-        end
-      end
-    
-      module InstanceMethods
-        private
-        
-        # Force the encoding of all string values when setting the instance's values.
-        def _refresh_set_values(values)
-          super(force_hash_encoding(values))
-        end
-        
-        # Force the encoding of all string values when setting the instance's values.
-        def _save_set_values(values)
-          super(force_hash_encoding(values))
-        end
-        
-        # Force the encoding for all string values in the given row hash.
-        def force_hash_encoding(row)
-          fe = model.forced_encoding
-          row.values.each{|v| v.force_encoding(fe) if v.is_a?(String)} if fe
-          row
-        end
-        
-        # Force the encoding of all returned strings to the model's forced_encoding.
-        def typecast_value(column, value)
-          s = super
-          if s.is_a?(String) && (fe = model.forced_encoding)
-            s = s.dup if s.frozen?
-            s.force_encoding(fe)
-          end
-          s
-        end
-      end
-    end
-  end
-end
-else
-# :nocov:
-  raise LoadError, 'ForceEncoding plugin only works on Ruby 1.9+'
-# :nocov:
-end

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

@@ -1,125 +0,0 @@
-module Sequel
-  module Plugins
-    # Sequel's built-in hook class methods plugin is designed for backwards
-    # compatibility.  Its use is not encouraged, it is recommended to use
-    # instance methods and super instead of this plugin.  What this plugin
-    # allows you to do is, for example:
-    #
-    #   # Block only, can cause duplicate hooks if code is reloaded
-    #   before_save{self.created_at = Time.now}
-    #   # Block with tag, safe for reloading
-    #   before_save(:set_created_at){self.created_at = Time.now}
-    #   # Tag only, safe for reloading, calls instance method
-    #   before_save(:set_created_at)
-    #
-    # Pretty much anything you can do with a hook class method, you can also
-    # do with an instance method instead:
-    #
-    #    def before_save
-    #      return false if super == false
-    #      self.created_at = Time.now
-    #    end
-    #
-    # Note that returning false in any before hook block will skip further
-    # before hooks and abort the action.  So if a before_save hook block returns
-    # false, future before_save hook blocks are not called, and the save is aborted.
-    # 
-    # Usage:
-    #
-    #   # Allow use of hook class methods in all model subclasses (called before loading subclasses)
-    #   Sequel::Model.plugin :hook_class_methods
-    #
-    #   # Allow the use of hook class methods in the Album class
-    #   Album.plugin :hook_class_methods
-    module HookClassMethods
-      # Set up the hooks instance variable in the model.
-      def self.apply(model)
-        hooks = model.instance_variable_set(:@hooks, {})
-        Model::HOOKS.each{|h| hooks[h] = []}
-      end
-
-      module ClassMethods
-        Model::HOOKS.each{|h| class_eval("def #{h}(method = nil, &block); add_hook(:#{h}, method, &block) end", __FILE__, __LINE__)}
-
-        # This adds a new hook type. It will define both a class
-        # method that you can use to add hooks, as well as an instance method
-        # that you can use to call all hooks of that type.  The class method
-        # can be called with a symbol or a block or both.  If a block is given and
-        # and symbol is not, it adds the hook block to the hook type.  If a block
-        # and symbol are both given, it replaces the hook block associated with
-        # that symbol for a given hook type, or adds it if there is no hook block
-        # with that symbol for that hook type.  If no block is given, it assumes
-        # the symbol specifies an instance method to call and adds it to the hook
-        # type.
-        #
-        # If any before hook block returns false, the instance method will return false
-        # immediately without running the rest of the hooks of that type.
-        #
-        # It is recommended that you always provide a symbol to this method,
-        # for descriptive purposes.  It's only necessary to do so when you 
-        # are using a system that reloads code.
-        # 
-        # Example of usage:
-        #
-        #  class MyModel
-        #   add_hook_type :before_move_to
-        #   before_move_to(:check_move_allowed){|o| o.allow_move?}
-        #   def move_to(there)
-        #     return if before_move_to == false
-        #     # move MyModel object to there
-        #   end
-        #  end
-        #
-        # Do not call this method with untrusted input, as that can result in
-        # arbitrary code execution.
-        def add_hook_type(*hooks)
-          Model::HOOKS.concat(hooks)
-          hooks.each do |hook|
-            @hooks[hook] = []
-            instance_eval("def #{hook}(method = nil, &block); add_hook(:#{hook}, method, &block) end", __FILE__, __LINE__)
-            class_eval("def #{hook}; model.hook_blocks(:#{hook}){|b| return false if instance_eval(&b) == false}; end", __FILE__, __LINE__)
-          end
-        end
-    
-        # Returns true if there are any hook blocks for the given hook.
-        def has_hooks?(hook)
-          !@hooks[hook].empty?
-        end
-    
-        # Yield every block related to the given hook.
-        def hook_blocks(hook)
-          @hooks[hook].each{|k,v| yield v}
-        end
-
-        Plugins.inherited_instance_variables(self, :@hooks=>:hash_dup)
-    
-        private
-    
-        # Add a hook block to the list of hook methods.
-        # If a non-nil tag is given and it already is in the list of hooks,
-        # replace it with the new block.
-        def add_hook(hook, tag, &block)
-          unless block
-            (raise Error, 'No hook method specified') unless tag
-            block = proc {send tag}
-          end
-          h = @hooks[hook]
-          if tag && (old = h.find{|x| x[0] == tag})
-            old[1] = block
-          else
-            if hook.to_s =~ /^before/
-              h.unshift([tag,block])
-            else
-              h << [tag, block]
-            end
-          end
-        end
-      end
-
-      module InstanceMethods
-        Model::BEFORE_HOOKS.each{|h| class_eval("def #{h}; model.hook_blocks(:#{h}){|b| return false if instance_eval(&b) == false}; super; end", __FILE__, __LINE__)}
-        Model::AFTER_HOOKS.each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_eval(&b)}; end", __FILE__, __LINE__)}
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-module Sequel
-  module Plugins
-    # InputTransformer is a plugin that allows generic transformations
-    # of input values in model column setters.  Example:
-    #
-    #   Album.plugin :input_transformer
-    #   Album.add_input_transformer(:reverser){|v| v.is_a?(String) ? v.reverse : v}
-    #   album = Album.new(:name=>'foo')
-    #   album.name # => 'oof'
-    #
-    # You can specifically set some columns to skip some input
-    # input transformers:
-    #
-    #   Album.skip_input_transformer(:reverser, :foo)
-    #   Album.new(:foo=>'bar').foo # => 'bar'
-    # 
-    # Usage:
-    #
-    #   # Make all model subclass instances support input transformers (called before loading subclasses)
-    #   Sequel::Model.plugin :input_transformer
-    #
-    #   # Make the Album class support input transformers 
-    #   Album.plugin :input_transformer
-    module InputTransformer
-      def self.apply(model, *)
-        model.instance_eval do
-          @input_transformers = {}
-          @input_transformer_order = []
-          @skip_input_transformer_columns = {}
-        end
-      end
-
-      # If an input transformer is given in the plugin call,
-      # add it as a transformer
-      def self.configure(model, transformer_name=nil, &block)
-        model.add_input_transformer(transformer_name, &block) if transformer_name || block
-      end
-
-      module ClassMethods
-        # Hash of input transformer name symbols to transformer callables.
-        attr_reader :input_transformers
-
-        # The order in which to call the input transformers.
-        attr_reader :input_transformer_order
-
-        Plugins.inherited_instance_variables(self, :@skip_input_transformer_columns=>:hash_dup, :@input_transformers=>:dup, :@input_transformer_order=>:dup)
-
-        # Add an input transformer to this model.
-        def add_input_transformer(transformer_name, &block)
-          raise(Error, 'must provide both transformer name and block when adding input transformer') unless transformer_name && block
-          @input_transformers[transformer_name] = block
-          @input_transformer_order.unshift(transformer_name)
-          @skip_input_transformer_columns[transformer_name] = []
-        end
-
-        # Set columns that the transformer should skip.
-        def skip_input_transformer(transformer_name, *columns)
-          @skip_input_transformer_columns[transformer_name].concat(columns).uniq!
-        end
-
-        # Return true if the transformer should not be called for the given column.
-        def skip_input_transformer?(transformer_name, column)
-          @skip_input_transformer_columns[transformer_name].include?(column)
-        end
-      end
-
-      module InstanceMethods
-        # Transform the input using all of the transformers, except those explicitly
-        # skipped, before setting the value in the model object.
-        def []=(k, v)
-          model.input_transformer_order.each do |transformer_name|
-            v = model.input_transformers[transformer_name].call(v) unless model.skip_input_transformer?(transformer_name, k)
-          end
-          super
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-module Sequel
-  module Plugins
-    # If the model's dataset selects explicit columns and the
-    # database supports it, the insert_returning_select plugin will
-    # automatically set the RETURNING clause on the dataset used to
-    # insert rows to the columns selected, which allows the default model
-    # support to run the insert and refresh of the data in a single
-    # query, instead of two separate queries.  This is Sequel's default
-    # behavior when the model does not select explicit columns.
-    #
-    # Usage:
-    #
-    #   # Make all model subclasses automatically setup insert returning clauses
-    #   Sequel::Model.plugin :insert_returning_select
-    #
-    #   # Make the Album class automatically setup insert returning clauses
-    #   Album.plugin :insert_returning_select
-    module InsertReturningSelect
-      # Modify the current model's dataset selection, if the model
-      # has a dataset.
-      def self.configure(model)
-        model.instance_eval do
-          self.dataset = dataset if @dataset && @dataset.opts[:select]
-        end
-      end
-
-      module ClassMethods
-        # The dataset to use to insert new rows.  For internal use only.
-        attr_reader :instance_insert_dataset
-
-        private
-
-        # When reseting the instance dataset, also reset the instance_insert_dataset.
-        def reset_instance_dataset
-          ret = super
-          ds = @instance_dataset
-
-          if columns = insert_returning_columns(ds)
-            ds = ds.returning(*columns)
-          end
-          @instance_insert_dataset = ds
-
-          ret
-        end
-
-        # Determine the columns to use for the returning clause, or return nil
-        # if they can't be determined and a returning clause should not be
-        # added automatically.
-        def insert_returning_columns(ds)
-          return unless ds.supports_returning?(:insert)
-          return unless values = ds.opts[:select]
-
-          values = values.map{|v| ds.unqualified_column_for(v)}
-          if values.all?
-            values
-          end
-        end
-      end
-      
-      module InstanceMethods
-        private
-
-        # Use the instance_insert_dataset as the base dataset for the insert.
-        def _insert_dataset
-          use_server(model.instance_insert_dataset)
-        end
-      end
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-module Sequel
-  module Plugins
-    # This plugin allows you to add filters on a per object basis that
-    # restrict updating or deleting the object.  It's designed for cases
-    # where you would normally have to drop down to the dataset level
-    # to get the necessary control, because you only want to delete or
-    # update the rows in certain cases based on the current status of
-    # the row in the database.
-    # 
-    #   class Item < Sequel::Model
-    #     plugin :instance_filters
-    #   end
-    #
-    #   # These are two separate objects that represent the same
-    #   # database row. 
-    #   i1 = Item.first(:id=>1, :delete_allowed=>false)
-    #   i2 = Item.first(:id=>1, :delete_allowed=>false)
-    #
-    #   # Add an instance filter to the object. This filter is in effect
-    #   # until the object is successfully updated or deleted.
-    #   i1.instance_filter(:delete_allowed=>true)
-    #
-    #   # Attempting to delete the object where the filter doesn't
-    #   # match any rows raises an error.
-    #   i1.delete # raises Sequel::NoExistingObject
-    #
-    #   # The other object that represents the same row has no
-    #   # instance filters, and can be updated normally.
-    #   i2.update(:delete_allowed=>true)
-    #
-    #   # Even though the filter is now still in effect, since the
-    #   # database row has been updated to allow deleting,
-    #   # delete now works.
-    #   i1.delete
-    #
-    # This plugin sets the require_modification flag on the model,
-    # so if the model's dataset doesn't provide an accurate number
-    # of matched rows, this could result in invalid exceptions being raised.
-    module InstanceFilters
-      # Exception class raised when updating or deleting an object does
-      # not affect exactly one row.
-      Error = Sequel::NoExistingObject
-      
-      # Set the require_modification flag to true for the model.
-      def self.configure(model)
-        model.require_modification = true
-      end
-
-      module InstanceMethods
-        # Clear the instance filters after successfully destroying the object.
-        def after_destroy
-          super
-          clear_instance_filters
-        end
-        
-        # Clear the instance filters after successfully updating the object.
-        def after_update
-          super
-          clear_instance_filters
-        end
-
-        # Freeze the instance filters when freezing the object
-        def freeze
-          instance_filters.freeze
-          super
-        end
-      
-        # Add an instance filter to the array of instance filters
-        # Both the arguments given and the block are passed to the
-        # dataset's filter method.
-        def instance_filter(*args, &block)
-          instance_filters << [args, block]
-        end
-      
-        private
-        
-        # If there are any instance filters, make sure not to use the
-        # instance delete optimization.
-        def _delete_without_checking
-          if @instance_filters && !@instance_filters.empty?
-            _delete_dataset.delete 
-          else
-            super
-          end
-        end
-
-        # Duplicate internal structures when duplicating model instance.
-        def initialize_copy(other)
-          super
-          @instance_filters = other.send(:instance_filters).dup
-          self
-        end
-      
-        # Lazily initialize the instance filter array.
-        def instance_filters
-          @instance_filters ||= []
-        end
-        
-        # Apply the instance filters to the given dataset
-        def apply_instance_filters(ds)
-          instance_filters.inject(ds){|ds1, i| ds1.filter(*i[0], &i[1])}
-        end
-        
-        # Clear the instance filters.
-        def clear_instance_filters
-          instance_filters.clear
-        end
-        
-        # Apply the instance filters to the dataset returned by super.
-        def _delete_dataset
-          apply_instance_filters(super)
-        end
-        
-        # Apply the instance filters to the dataset returned by super.
-        def _update_dataset
-          apply_instance_filters(super)
-        end
-
-        # Only use prepared statements for update and delete queries
-        # if there are no instance filters.
-        def use_prepared_statements_for?(type)
-          if (type == :update || type == :delete) && !instance_filters.empty?
-            false
-          else
-            super
-          end
-        end
-      end
-    end
-  end
-end