asana2flowdock 1.0.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/eval_inspect.rb

@@ -0,0 +1,182 @@
+# The eval_inspect extension changes #inspect for Sequel::SQL::Expression
+# subclasses to return a string suitable for ruby's eval, such that
+#
+#   eval(obj.inspect) == obj
+#
+# is true.  The above code is true for most of ruby's simple classes such
+# as String, Integer, Float, and Symbol, but it's not true for classes such
+# as Time, Date, and BigDecimal.  Sequel attempts to handle situations where
+# instances of these classes are a component of a Sequel expression.
+#
+# To load the extension:
+#
+#   Sequel.extension :eval_inspect
+
+#
+module Sequel
+  module EvalInspect
+    # Special case objects where inspect does not generally produce input
+    # suitable for eval.  Used by Sequel::SQL::Expression#inspect so that
+    # it can produce a string suitable for eval even if components of the
+    # expression have inspect methods that do not produce strings suitable
+    # for eval.
+    def eval_inspect(obj)
+      case obj
+      when Sequel::SQL::Blob, Sequel::LiteralString, Sequel::SQL::ValueList
+        "#{obj.class}.new(#{obj.inspect})"
+      when Array
+        "[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
+      when Hash
+        "{#{obj.map{|k, v| "#{eval_inspect(k)} => #{eval_inspect(v)}"}.join(', ')}}"
+      when Time
+        datepart = "%Y-%m-%dT" unless obj.is_a?(Sequel::SQLTime)
+        if RUBY_VERSION < '1.9'
+        # :nocov:
+          # Time on 1.8 doesn't handle %N (or %z on Windows), manually set the usec value in the string
+          hours, mins = obj.utc_offset.divmod(3600)
+          mins /= 60
+          "#{obj.class}.parse(#{obj.strftime("#{datepart}%H:%M:%S.#{sprintf('%06i%+03i%02i', obj.usec, hours, mins)}").inspect})#{'.utc' if obj.utc?}"
+        # :nocov:
+        else
+          "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
+        end
+      when DateTime
+        # Ignore date of calendar reform
+        "DateTime.parse(#{obj.strftime('%FT%T.%N%z').inspect})"
+      when Date
+        # Ignore offset and date of calendar reform
+        "Date.new(#{obj.year}, #{obj.month}, #{obj.day})"
+      when BigDecimal
+        "BigDecimal.new(#{obj.to_s.inspect})"
+      else
+        obj.inspect
+      end
+    end
+  end
+
+  extend EvalInspect
+
+  module SQL
+    class Expression
+      # Attempt to produce a string suitable for eval, such that:
+      #
+      #   eval(obj.inspect) == obj
+      def inspect
+        # Assume by default that the object can be recreated by calling
+        # self.class.new with any attr_reader values defined on the class,
+        # in the order they were defined.
+        klass = self.class
+        args = inspect_args.map do |arg|
+          if arg.is_a?(String) && arg =~ /\A\*/
+            # Special case string arguments starting with *, indicating that
+            # they should return an array to be splatted as the remaining arguments
+            send(arg.sub('*', '')).map{|a| Sequel.eval_inspect(a)}.join(', ')
+          else
+            Sequel.eval_inspect(send(arg))
+          end
+        end
+        "#{klass}.#{inspect_new_method}(#{args.join(', ')})"
+      end
+
+      private
+
+      # Which attribute values to use in the inspect string.
+      def inspect_args
+        self.class.comparison_attrs
+      end
+
+      # Use the new method by default for creating new objects.
+      def inspect_new_method
+        :new
+      end
+    end
+
+    class ComplexExpression
+      private
+
+      # ComplexExpression's initializer uses a splat for the operator arguments.
+      def inspect_args
+        [:op, "*args"]
+      end
+    end
+
+    class Constant
+      # Constants to lookup in the Sequel module.
+      INSPECT_LOOKUPS = [:CURRENT_DATE, :CURRENT_TIMESTAMP, :CURRENT_TIME, :SQLTRUE, :SQLFALSE, :NULL, :NOTNULL]
+
+      # Reference the constant in the Sequel module if there is
+      # one that matches.
+      def inspect
+        INSPECT_LOOKUPS.each do |c|
+          return "Sequel::#{c}" if Sequel.const_get(c) == self
+        end
+        super
+      end
+    end
+
+    class CaseExpression
+      private
+
+      # CaseExpression's initializer checks whether an argument was
+      # provided, to differentiate CASE WHEN from CASE NULL WHEN, so
+      # check if an expression was provided, and only include the
+      # expression in the inspect output if so.
+      def inspect_args
+        if expression?
+          [:conditions, :default, :expression]
+        else
+          [:conditions, :default]
+        end
+      end
+    end
+
+    class Function
+      private
+
+      # Function uses a new! method for creating functions with options,
+      # since Function.new does not allow for an options hash.
+      def inspect_new_method
+        :new!
+      end
+    end
+
+    class JoinOnClause
+      private
+
+      # JoinOnClause's initializer takes the on argument as the first argument
+      # instead of the last.
+      def inspect_args
+        [:on, :join_type, :table_expr] 
+      end
+    end
+
+    class JoinUsingClause
+      private
+
+      # JoinOnClause's initializer takes the using argument as the first argument
+      # instead of the last.
+      def inspect_args
+        [:using, :join_type, :table_expr] 
+      end
+    end
+
+    class OrderedExpression
+      private
+
+      # OrderedExpression's initializer takes the :nulls information inside a hash,
+      # so if a NULL order was given, include a hash with that information.
+      def inspect_args
+        if nulls
+          [:expression, :descending, :opts_hash]
+        else
+          [:expression, :descending]
+        end
+      end
+
+      # A hash of null information suitable for passing to the initializer.
+      def opts_hash
+        {:nulls=>nulls} 
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/filter_having.rb

@@ -0,0 +1,59 @@
+# The filter_having extension allows Dataset#filter, #and, #or
+# and #exclude to operate on the HAVING clause if the dataset
+# already has a HAVING clause, which was the historical behavior
+# before Sequel 4.  It is only recommended to use this for
+# backwards compatibility.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:filter_having)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:filter_having)
+
+#
+module Sequel
+  module FilterHaving
+    # Operate on HAVING clause if HAVING clause already present.
+    def and(*cond, &block)
+      if @opts[:having]
+        having(*cond, &block)
+      else
+        super
+      end
+    end
+
+    # Operate on HAVING clause if HAVING clause already present.
+    def exclude(*cond, &block)
+      if @opts[:having]
+        exclude_having(*cond, &block)
+      else
+        super
+      end
+    end
+
+    # Operate on HAVING clause if HAVING clause already present.
+    def filter(*cond, &block)
+      if @opts[:having]
+        having(*cond, &block)
+      else
+        super
+      end
+    end
+
+    # Operate on HAVING clause if HAVING clause already present.
+    def or(*cond, &block)
+      if having = @opts[:having]
+        cond = cond.first if cond.size == 1
+        clone(:having => SQL::BooleanExpression.new(:OR, having, filter_expr(cond, &block)))
+      else
+        super
+      end
+    end
+  end
+
+  Dataset.register_extension(:filter_having, FilterHaving)
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/from_block.rb

@@ -0,0 +1,32 @@
+# The from_block extension changes Database#from so that blocks given
+# to it are treated as virtual rows applying to the FROM clause,
+# instead of virtual rows applying to the WHERE clause.  This will
+# probably be made the default in the next major version of Sequel.
+#
+# This makes it easier to use table returning functions:
+#
+#   DB.from{table_function(1)}
+#   # SELECT * FROM table_function(1)
+#
+# To load the extension into the database:
+#
+#   DB.extension :from_block
+
+#
+module Sequel
+  module Database::FromBlock
+    # If a block is given, make it affect the FROM clause:
+    #   DB.from{table_function(1)}
+    #   # SELECT * FROM table_function(1)
+    def from(*args, &block)
+      if block
+        @default_dataset.from(*args, &block)
+      else
+        super
+      end
+    end
+  end
+
+  Database.register_extension(:from_block, Database::FromBlock)
+end
+

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/graph_each.rb

@@ -0,0 +1,75 @@
+# The graph_each extension adds Dataset#graph_each and
+# makes Dataset#each call #graph_each if the dataset has been graphed.
+# Dataset#graph_each splits result hashes into subhashes per table:
+#
+#   DB[:a].graph(:b, :id=>:b_id).all
+#   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:graph_each)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:graph_each)
+
+#
+module Sequel
+  module GraphEach
+    # Call graph_each for graphed datasets that are not being eager graphed.
+    def each
+      if @opts[:graph] && !@opts[:eager_graph]
+        graph_each{|r| yield r}
+      else
+        super
+      end
+    end
+
+    private
+
+    # Fetch the rows, split them into component table parts,
+    # tranform and run the row_proc on each part (if applicable),
+    # and yield a hash of the parts.
+    def graph_each
+      # Reject tables with nil datasets, as they are excluded from
+      # the result set
+      datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
+      # Get just the list of table aliases into a local variable, for speed
+      table_aliases = datasets.collect{|ta,ds| ta}
+      # Get an array of arrays, one for each dataset, with
+      # the necessary information about each dataset, for speed
+      datasets = datasets.collect{|ta, ds| [ta, ds, ds.row_proc]}
+      # Use the manually set graph aliases, if any, otherwise
+      # use the ones automatically created by .graph
+      column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases]
+      fetch_rows(select_sql) do |r|
+        graph = {}
+        # Create the sub hashes, one per table
+        table_aliases.each{|ta| graph[ta]={}}
+        # Split the result set based on the column aliases
+        # If there are columns in the result set that are
+        # not in column_aliases, they are ignored
+        column_aliases.each do |col_alias, tc|
+          ta, column = tc
+          graph[ta][column] = r[col_alias]
+        end
+        # For each dataset run the row_proc if applicable
+        datasets.each do |ta,ds,rp|
+          g = graph[ta]
+          graph[ta] = if g.values.any?{|x| !x.nil?}
+            rp ? rp.call(g) : g
+          else
+            nil
+          end
+        end
+
+        yield graph
+      end
+      self
+    end
+  end
+
+  Dataset.register_extension(:graph_each, GraphEach)
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/hash_aliases.rb

@@ -0,0 +1,45 @@
+# The hash_aliases extension allows Dataset#select and Dataset#from
+# to treat a hash argument as an alias specification, with keys
+# being the expressions and values being the aliases, 
+# which was the historical behavior before Sequel 4.
+# It is only recommended to use this for backwards compatibility.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:hash_aliases)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:hash_aliases)
+
+#
+module Sequel
+  module HashAliases
+    def from(*source)
+      super(*convert_hash_aliases(source))
+    end
+
+    def select(*columns, &block)
+      virtual_row_columns(columns, block)
+      super(*convert_hash_aliases(columns), &nil)
+    end
+
+    private
+
+    def convert_hash_aliases(columns)
+      m = []
+      columns.each do |i|
+        if i.is_a?(Hash)
+          m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)})
+        else
+          m << i
+        end
+      end
+      m
+    end
+  end
+
+  Dataset.register_extension(:hash_aliases, HashAliases)
+end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/extensions/inflector.rb

@@ -0,0 +1,246 @@
+# The inflector extension adds inflection instance methods to String, which allows the easy transformation of
+# words from singular to plural, class names to table names, modularized class
+# names to ones without, and class names to foreign keys.  It exists for 
+# backwards compatibility to legacy Sequel code.
+#
+# To load the extension:
+#
+#   Sequel.extension :inflector
+
+class String
+  # This module acts as a singleton returned/yielded by String.inflections,
+  # which is used to override or specify additional inflection rules. Examples:
+  #
+  #   String.inflections do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable "equipment"
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+  # already have been loaded.
+  module Inflections
+    @plurals, @singulars, @uncountables = [], [], []
+
+    class << self
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.
+      attr_reader :plurals
+
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.
+      attr_reader :singulars
+
+      # Array of strings for words were the singular form is the same as the plural form
+      attr_reader :uncountables
+    end
+
+    # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
+    # the options are: :plurals, :singulars, :uncountables
+    #
+    # Examples:
+    #   clear :all
+    #   clear :plurals
+    def self.clear(scope = :all)
+      case scope
+      when :all
+        @plurals, @singulars, @uncountables = [], [], []
+      else
+        instance_variable_set("@#{scope}", [])
+      end
+    end
+
+    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+    #
+    # Examples:
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def self.irregular(singular, plural)
+      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+    end
+
+    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   plural(/(x|ch|ss|sh)$/i, '\1es')
+    def self.plural(rule, replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
+    def self.singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def self.uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    Sequel.require('default_inflections', 'model')
+    instance_eval(&Sequel::DEFAULT_INFLECTIONS_PROC)
+  end
+
+  # Yield the Inflections module if a block is given, and return
+  # the Inflections module.
+  def self.inflections
+    yield Inflections if block_given?
+    Inflections
+  end
+
+  # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
+  # is set to :lower then camelize produces lowerCamelCase.
+  #
+  # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+  #
+  # Examples
+  #   "active_record".camelize #=> "ActiveRecord"
+  #   "active_record".camelize(:lower) #=> "activeRecord"
+  #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
+  def camelize(first_letter_in_uppercase = :upper)
+    s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+    s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
+    s
+  end
+  alias_method :camelcase, :camelize
+
+  # Singularizes and camelizes the string.  Also strips out all characters preceding
+  # and including a period (".").
+  #
+  # Examples
+  #   "egg_and_hams".classify #=> "EggAndHam"
+  #   "post".classify #=> "Post"
+  #   "schema.post".classify #=> "Post"
+  def classify
+    sub(/.*\./, '').singularize.camelize
+  end
+
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize #=> Module
+  #   "Class".constantize #=> Class
+  def constantize
+    raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
+    Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  # Example
+  #   "puni_puni".dasherize #=> "puni-puni"
+  def dasherize
+    gsub(/_/, '-')
+  end
+
+  # Removes the module part from the expression in the string
+  #
+  # Examples
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+  #   "Inflections".demodulize #=> "Inflections"
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+
+  # Creates a foreign key name from a class name.
+  # +use_underscore+ sets whether the method should put '_' between the name and 'id'.
+  #
+  # Examples
+  #   "Message".foreign_key #=> "message_id"
+  #   "Message".foreign_key(false) #=> "messageid"
+  #   "Admin::Post".foreign_key #=> "post_id"
+  def foreign_key(use_underscore = true)
+    "#{demodulize.underscore}#{'_' if use_underscore}id"
+  end
+
+  # Capitalizes the first word and turns underscores into spaces and strips _id.
+  # Like titleize, this is meant for creating pretty output.
+  #
+  # Examples
+  #   "employee_salary" #=> "Employee salary"
+  #   "author_id" #=> "Author"
+  def humanize
+    gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  end
+
+  # Returns the plural form of the word in the string.
+  #
+  # Examples
+  #   "post".pluralize #=> "posts"
+  #   "octopus".pluralize #=> "octopi"
+  #   "sheep".pluralize #=> "sheep"
+  #   "words".pluralize #=> "words"
+  #   "the blue mailman".pluralize #=> "the blue mailmen"
+  #   "CamelOctopus".pluralize #=> "CamelOctopi"
+  def pluralize
+    result = dup
+    Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # The reverse of pluralize, returns the singular form of a word in a string.
+  #
+  # Examples
+  #   "posts".singularize #=> "post"
+  #   "octopi".singularize #=> "octopus"
+  #   "sheep".singluarize #=> "sheep"
+  #   "word".singluarize #=> "word"
+  #   "the blue mailmen".singularize #=> "the blue mailman"
+  #   "CamelOctopi".singularize #=> "CamelOctopus"
+  def singularize
+    result = dup
+    Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # Underscores and pluralizes the string.
+  #
+  # Examples
+  #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
+  #   "egg_and_ham".tableize #=> "egg_and_hams"
+  #   "fancyCategory".tableize #=> "fancy_categories"
+  def tableize
+    underscore.pluralize
+  end
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. Titleize is meant for creating pretty output.
+  #
+  # titleize is also aliased as as titlecase
+  #
+  # Examples
+  #   "man from the boondocks".titleize #=> "Man From The Boondocks"
+  #   "x-men: the last stand".titleize #=> "X Men: The Last Stand"
+  def titleize
+    underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
+  end
+  alias_method :titlecase, :titleize
+
+  # The reverse of camelize. Makes an underscored form from the expression in the string.
+  # Also changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "ActiveRecord".underscore #=> "active_record"
+  #   "ActiveRecord::Errors".underscore #=> active_record/errors
+  def underscore
+    gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+end