asana2flowdock 1.0.0 → 1.1.0

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

@@ -1,80 +0,0 @@
-module Sequel
-  module Plugins
-    # Sequel's built in schema plugin allows you to define your schema
-    # directly in the model using Model.set_schema (which takes a block
-    # similar to Database#create_table), and use Model.create_table to
-    # create a table using the schema information.
-    #
-    # This plugin is mostly suited to test code.  If there is any
-    # chance that your application's schema could change, you should
-    # be using the migration extension instead.
-    # 
-    # Usage:
-    #
-    #   # Add the schema methods to all model subclasses (called before loading subclasses)
-    #   Sequel::Model.plugin :schema
-    #
-    #   # Add the schema methods to the Album class
-    #   Album.plugin :schema
-    module Schema
-      module ClassMethods
-        # Creates table, using the column information from set_schema.
-        def create_table(*args, &block)
-          set_schema(*args, &block) if block
-          db.create_table(table_name, :generator=>@schema)
-          @db_schema = get_db_schema(true)
-          columns
-        end
-        
-        # Drops the table if it exists and then runs create_table.  Should probably
-        # not be used except in testing.
-        def create_table!(*args, &block)
-          drop_table?
-          create_table(*args, &block)
-        end
-
-        # Creates the table unless the table already exists
-        def create_table?(*args, &block)
-          create_table(*args, &block) unless table_exists?
-        end
-        
-        # Drops table.  If the table doesn't exist, this will probably raise an error.
-        def drop_table
-          db.drop_table(table_name)
-        end
-    
-        # Drops table if it already exists, do nothing if it doesn't exist.
-        def drop_table?
-          db.drop_table?(table_name)
-        end
-    
-        # Returns table schema created with set_schema for direct descendant of Model.
-        # Does not retreive schema information from the database, see db_schema if you
-        # want that.
-        def schema
-          @schema || (superclass.schema unless superclass == Model)
-        end
-    
-        # Defines a table schema (see Schema::Generator for more information).
-        #
-        # This is only needed if you want to use the create_table/create_table! methods.
-        # Will also set the dataset if you provide a name, as well as setting
-        # the primary key if you defined one in the passed block.
-        #
-        # In general, it is a better idea to use migrations for production code, as
-        # migrations allow changes to existing schema.  set_schema is mostly useful for
-        # test code or simple examples.
-        def set_schema(name = nil, &block)
-          set_dataset(db[name]) if name
-          @schema = db.create_table_generator(&block)
-          set_primary_key(@schema.primary_key_name) if @schema.primary_key_name
-        end
-        
-        # Returns true if table exists, false otherwise.
-        def table_exists?
-          db.table_exists?(table_name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module Sequel
-  module Plugins
-    # The scissors plugin adds class methods for update, delete, and destroy.
-    # It is so named because this is considered dangerous, since it is easy
-    # to write:
-    #
-    #   Album.delete
-    #
-    # and delete all rows in the table, when you meant to write:
-    #
-    #   album.delete
-    #
-    # and only delete a single row.
-    #
-    # This plugin is mostly useful for backwards compatibility, and not
-    # recommended for use in production.  However, it can cut down on
-    # verbosity in non-transactional test code, so it may be appropriate
-    # to use when testing.
-    #
-    # Usage:
-    #
-    #   # Make all model subclass run with scissors
-    #   Sequel::Model.plugin :scissors
-    #
-    #   # Make the Album class run with scissors
-    #   Album.plugin :scissors
-    module Scissors
-      module ClassMethods
-        Plugins.def_dataset_methods(self, [:update, :delete, :destroy])
-      end
-    end
-  end
-end

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

@@ -1,235 +0,0 @@
-module Sequel
-  module Plugins
-    # Sequel's built in Serialization plugin allows you to keep serialized
-    # ruby objects in the database, while giving you deserialized objects
-    # when you call an accessor.
-    #
-    # This plugin works by keeping the serialized value in the values, and
-    # adding a @deserialized_values hash.  The reader method for serialized columns
-    # will check the @deserialized_values for the value, return it if present,
-    # or deserialized the entry in @values and return it.  The writer method will
-    # set the @deserialized_values entry.  This plugin adds a before_save hook
-    # that serializes all @deserialized_values to @values.
-    #
-    # You can specify the serialization format as a pair of serializer/deserializer
-    # callable objects.  You can also specify the serialization format as a single
-    # symbol, if such a symbol has a registered serializer/deserializer pair in the
-    # plugin.  By default, the plugin registers the :marshal, :yaml, and :json
-    # serialization formats.  To register your own serialization formats, use
-    # Sequel::Plugins::Serialization.register_format.
-    # If you use yaml or json format, you need to require the libraries, Sequel
-    # does not do the requiring for you.
-    #
-    # You can specify the columns to serialize when loading the plugin, or later
-    # using the serialize_attributes class method.
-    #
-    # Because of how this plugin works, it must be used inside each model class
-    # that needs serialization, after any set_dataset method calls in that class.
-    # Otherwise, it is possible that the default column accessors will take
-    # precedence.
-    #
-    # == Example
-    #
-    #   # Require json if you plan to use it, as the plugin doesn't require it for you.
-    #   require 'json'
-    #
-    #   # Register custom serializer/deserializer pair, if desired
-    #   require 'sequel/plugins/serialization'
-    #   Sequel::Plugins::Serialization.register_format(:reverse,
-    #     lambda{|v| v.reverse},
-    #     lambda{|v| v.reverse})
-    #
-    #   class User < Sequel::Model
-    #     # Built-in format support when loading the plugin
-    #     plugin :serialization, :json, :permissions
-    #
-    #     # Built-in format support after loading the plugin using serialize_attributes
-    #     plugin :serialization
-    #     serialize_attributes :marshal, :permissions
-    #
-    #     # Use custom registered serialization format just like built-in format
-    #     serialize_attributes :reverse, :password
-    #
-    #     # Use a custom serializer/deserializer pair without registering
-    #     serialize_attributes [lambda{|v| v.reverse}, lambda{|v| v.reverse}], :password
-    #   end
-    #   user = User.create
-    #   user.permissions = { :global => 'read-only' }
-    #   user.save
-    #
-    # Note that if you mutate serialized column values without reassigning them,
-    # those changes won't be picked up by <tt>Model#save_changes</tt> or
-    # <tt>Model#update</tt>.  Example:
-    #
-    #   user = User[1]
-    #   user.permissions[:global] = 'foo'
-    #   user.save_changes # Will not pick up changes to permissions
-    #
-    # You can use the +serialization_modification_detection+ plugin to pick
-    # up such changes.
-    module Serialization
-      # The default serializers supported by the serialization module.
-      # Use register_format to add serializers to this hash.
-      REGISTERED_FORMATS = {}
-
-      # Set up the column readers to do deserialization and the column writers
-      # to save the value in deserialized_values.
-      def self.apply(model, *args)
-        model.instance_eval do
-          @deserialization_map = {}
-          @serialization_map = {}
-        end
-      end
-      
-      # Automatically call serialize_attributes with the format and columns unless
-      # no columns were provided.
-      def self.configure(model, format=nil, *columns)
-        model.serialize_attributes(format, *columns) unless columns.empty?
-      end
-
-      # Register a serializer/deserializer pair with a format symbol, to allow
-      # models to pick this format by name.  Both serializer and deserializer
-      # should be callable objects.
-      def self.register_format(format, serializer, deserializer)
-        REGISTERED_FORMATS[format] = [serializer, deserializer]
-      end
-      register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')},
-        lambda do |v|
-          begin
-            Marshal.load(v.unpack('m')[0])
-          rescue => e
-            begin
-              # Backwards compatibility for unpacked marshal output.
-              Marshal.load(v)
-            rescue
-              raise e
-            end
-          end
-        end)
-      register_format(:yaml, lambda{|v| v.to_yaml}, lambda{|v| YAML.load(v)})
-      register_format(:json, lambda{|v| Sequel.object_to_json(v)}, lambda{|v| Sequel.parse_json(v)})
-
-      module ClassMethods
-        # A hash with column name symbols and callable values, with the value
-        # called to deserialize the column.
-        attr_reader :deserialization_map
-
-        # A hash with column name symbols and callable values, with the value
-        # called to serialize the column.
-        attr_reader :serialization_map
-
-        # Module to store the serialized column accessor methods, so they can
-        # call be overridden and call super to get the serialization behavior
-        attr_accessor :serialization_module
-
-        Plugins.inherited_instance_variables(self, :@deserialization_map=>:dup, :@serialization_map=>:dup)
-        
-        # Create instance level reader that deserializes column values on request,
-        # and instance level writer that stores new deserialized values.
-        def serialize_attributes(format, *columns)
-          if format.is_a?(Symbol)
-            unless format = REGISTERED_FORMATS[format]
-              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{REGISTERED_FORMATS.keys.map{|k| k.inspect}.join})")
-            end
-          end
-          serializer, deserializer = format
-          raise(Error, "No columns given.  The serialization plugin requires you specify which columns to serialize") if columns.empty?
-          define_serialized_attribute_accessor(serializer, deserializer, *columns)
-        end
-        
-        # The columns that will be serialized.  This is only for
-        # backwards compatibility, use serialization_map in new code.
-        def serialized_columns
-          serialization_map.keys
-        end
-
-        private
-
-        # Add serializated attribute acessor methods to the serialization_module
-        def define_serialized_attribute_accessor(serializer, deserializer, *columns)
-          m = self
-          include(self.serialization_module ||= Module.new) unless serialization_module
-          serialization_module.class_eval do
-            columns.each do |column|
-              m.serialization_map[column] = serializer
-              m.deserialization_map[column] = deserializer
-              define_method(column) do 
-                if deserialized_values.has_key?(column)
-                  deserialized_values[column]
-                elsif frozen?
-                  deserialize_value(column, super())
-                else
-                  deserialized_values[column] = deserialize_value(column, super())
-                end
-              end
-              define_method("#{column}=") do |v| 
-                if !changed_columns.include?(column) && (new? || send(column) != v)
-                  changed_columns << column
-                end
-
-                deserialized_values[column] = v
-              end
-            end
-          end
-        end
-      end
-
-      module InstanceMethods
-        # Hash of deserialized values, used as a cache.
-        def deserialized_values
-          @deserialized_values ||= {}
-        end
-
-        # Freeze the deserialized values
-        def freeze
-          deserialized_values.freeze
-          super
-        end
-
-        private
-
-        # Serialize deserialized values before saving
-        def _before_validation
-          serialize_deserialized_values
-          super
-        end
-        
-        # Clear any cached deserialized values when doing a manual refresh.
-        def _refresh_set_values(hash)
-          @deserialized_values.clear if @deserialized_values
-          super
-        end
-
-        # Deserialize the column value.  Called when the model column accessor is called to
-        # return a deserialized value.
-        def deserialize_value(column, v)
-          unless v.nil?
-            raise Sequel::Error, "no entry in deserialization_map for #{column.inspect}" unless callable = model.deserialization_map[column]
-            callable.call(v)
-          end
-        end
-
-        # Dup the deserialized values when duping model instance.
-        def initialize_copy(other)
-          super
-          @deserialized_values = other.deserialized_values.dup
-          self
-        end
-
-        # Serialize all deserialized values
-        def serialize_deserialized_values
-          deserialized_values.each{|k,v| @values[k] = serialize_value(k, v)}
-        end
-
-        # Serialize the column value.  Called before saving to ensure the serialized value
-        # is saved in the database.
-        def serialize_value(column, v)
-          unless v.nil?
-            raise Sequel::Error, "no entry in serialization_map for #{column.inspect}" unless callable = model.serialization_map[column]
-            callable.call(v)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-module Sequel
-  module Plugins
-    # This plugin extends the serialization plugin and enables it to detect
-    # changes in serialized values by checking whether the current
-    # deserialized value is the same as the original deserialized value.
-    # The serialization plugin does not do such checks by default, as they
-    # often aren't needed and can hurt performance.
-    #
-    # Note that for this plugin to work correctly, the values you are
-    # serializing must roundtrip correctly (i.e. deserialize(serialize(value))
-    # should equal value).  This is true in most cases, but not in all.  For
-    # example, ruby symbols round trip through yaml, but not json (as they get
-    # turned into strings in json).
-    #
-    # == Example
-    #
-    #   require 'sequel'
-    #   require 'json'
-    #   class User < Sequel::Model
-    #     plugin :serialization, :json, :permissions
-    #     plugin :serialization_modification_detection
-    #   end
-    #   user = User.create(:permissions => {})
-    #   user.permissions[:global] = 'read-only'
-    #   user.save_changes
-    module SerializationModificationDetection
-      # Load the serialization plugin automatically.
-      def self.apply(model)
-        model.plugin :serialization
-      end
-      
-      module InstanceMethods
-        # Clear the cache of original deserialized values after saving so that it doesn't
-        # show the column is modified after saving.
-        def after_save
-          super
-          @original_deserialized_values = @deserialized_values
-        end
-
-        # Detect which serialized columns have changed.
-        def changed_columns
-          cc = super
-          cc = cc.dup if frozen?
-          deserialized_values.each{|c, v| cc << c if !cc.include?(c) && original_deserialized_value(c) != v} 
-          cc
-        end
-
-        # Freeze the original deserialized values when freezing the instance.
-        def freeze
-          @original_deserialized_values ||= {}
-          @original_deserialized_values.freeze
-          super
-        end
-
-        private
-
-        # Duplicate the original deserialized values when duplicating instance.
-        def initialize_copy(other)
-          super
-          if o = other.instance_variable_get(:@original_deserialized_values)
-            @original_deserialized_values = o.dup
-          end
-          self
-        end
-
-        # For new objects, serialize any existing deserialized values so that changes can
-        # be detected.
-        def initialize_set(values)
-          super
-          serialize_deserialized_values
-        end
-
-        # Return the original deserialized value of the column, caching it to improve performance.
-        def original_deserialized_value(column)
-          if frozen?
-            @original_deserialized_values[column] || deserialize_value(column, self[column])
-          else
-            (@original_deserialized_values ||= {})[column] ||= deserialize_value(column, self[column])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-module Sequel
-  module Plugins
-    # The sharding plugin augments Sequel's default model sharding support
-    # in the following ways:
-    #
-    # * It automatically sets model instances to be saved back to the
-    #   shard they were retreived from.
-    # * It makes model associations use the same shard as the model
-    #   object.
-    # * It adds a slightly nicer API for creating model instances on
-    #   specific shards.
-    # 
-    # Usage:
-    #
-    #   # Add the sharding support to all model subclasses (called before loading subclasses)
-    #   Sequel::Model.plugin :sharding
-    #
-    #   # Add the sharding support to the Album class
-    #   Album.plugin :sharding
-    module Sharding
-      module ClassMethods
-        # Create a new object on the given shard s.
-        def create_using_server(s, values={}, &block)
-          new_using_server(s, values, &block).save
-        end
-
-        # Eager load the association with the given eager loader options.
-        def eager_load_results(opts, eo, &block)
-          if (s = eo[:self]) && (server = s.opts[:server])
-            eb = eo[:eager_block]
-            set_server = proc do |ds|
-              ds = eb.call(ds) if eb
-              ds = ds.server(server) unless ds.opts[:server]
-              ds
-            end
-            eo = eo.merge(:eager_block=>set_server)
-          end
-
-          super
-        end
-
-        # Return a newly instantiated object that is tied to the given
-        # shard s.  When the object is saved, a record will be inserted
-        # on shard s.
-        def new_using_server(s, values={}, &block)
-          new(values, &block).set_server(s)
-        end
-
-        private
-
-        # Set the server for each graphed dataset to the current server
-        # unless the graphed dataset already has a server set.
-        def eager_graph_dataset(opts, eager_options)
-          ds = super
-          if s = eager_options[:self].opts[:server]
-            ds = ds.server(s) unless ds.opts[:server]
-          end
-          ds
-        end
-      end
-
-      module InstanceMethods
-        # Set the server that this object is tied to, unless it has
-        # already been set.  Returns self.
-        def set_server?(s)
-          @server ||= s
-          self
-        end
-
-        private
-
-        # Ensure that association datasets are tied to the correct shard.
-        def _apply_association_options(*args)
-          use_server(super)
-        end
-
-        # Don't use an associated object loader, as it won't respect the shard used.
-        def _associated_object_loader(opts, dynamic_opts)
-          nil
-        end
-
-        # Ensure that the join table for many_to_many associations uses the correct shard.
-        def _join_table_dataset(opts)
-          use_server(super)
-        end
-
-        # If creating the object by doing <tt>add_association</tt> for a
-        # +many_to_many+ association, make sure the associated object is created on the
-        # current object's shard, unless the passed object already has an assigned shard.
-        def ensure_associated_primary_key(opts, o, *args)
-          o.set_server?(@server) if o.respond_to?(:set_server?)
-          super
-        end
-
-        # Don't use primary key lookup to load associated objects, since that will not
-        # respect the current object's server.
-        def load_with_primary_key_lookup?(opts, dynamic_opts)
-          false
-        end
-      end
-
-      module DatasetMethods
-        # If a row proc exists on the dataset, replace it with one that calls the
-        # previous row_proc, but calls set_server on the output of that row_proc,
-        # ensuring that objects retrieved by a specific shard know which shard they
-        # are tied to.
-        def server(s)
-          ds = super
-          if rp = row_proc
-            ds.row_proc = proc{|r| rp.call(r).set_server(s)}
-          end
-          ds
-        end
-      end
-    end
-  end
-end