linkage 0.0.8 → 0.1.0.pre

data/lib/linkage/decollation.rb

@@ -1,93 +0,0 @@
-# encoding: utf-8
-module Linkage
-  module Decollation
-    def decollate(string, database_type, collation)
-      case database_type
-      when :mysql
-        decollate_mysql(string, collation)
-      else
-        string
-      end
-    end
-
-    def decollate_mysql(string, collation)
-      case collation
-      when "latin1_swedish_ci"
-        decollate_mysql_latin1_swedish_ci(string)
-      else
-        string
-      end
-    end
-
-    def decollate_mysql_latin1_swedish_ci(string)
-      result = string.strip
-      result.each_char.with_index do |char, i|
-        case char
-        when 'A', 'a', 'À', 'Á', 'Â', 'Ã', 'à', 'á', 'â', 'ã'
-          result[i] = 'A'
-        when 'B', 'b'
-          result[i] = 'B'
-        when 'C', 'c', 'Ç', 'ç'
-          result[i] = 'C'
-        when 'D', 'd', 'Ð', 'ð'
-          result[i] = 'D'
-        when 'E', 'e', 'È', 'É', 'Ê', 'Ë', 'è', 'é', 'ê', 'ë'
-          result[i] = 'E'
-        when 'F', 'f'
-          result[i] = 'F'
-        when 'G', 'g'
-          result[i] = 'G'
-        when 'H', 'h'
-          result[i] = 'H'
-        when 'I', 'i', 'Ì', 'Í', 'Î', 'Ï', 'ì', 'í', 'î', 'ï'
-          result[i] = 'I'
-        when 'J', 'j'
-          result[i] = 'J'
-        when 'K', 'k'
-          result[i] = 'K'
-        when 'L', 'l'
-          result[i] = 'L'
-        when 'M', 'm'
-          result[i] = 'M'
-        when 'N', 'n', 'Ñ', 'ñ'
-          result[i] = 'N'
-        when 'O', 'o', 'Ò', 'Ó', 'Ô', 'Õ', 'ò', 'ó', 'ô', 'õ'
-          result[i] = 'O'
-        when 'P', 'p'
-          result[i] = 'P'
-        when 'Q', 'q'
-          result[i] = 'Q'
-        when 'R', 'r'
-          result[i] = 'R'
-        when 'S', 's'
-          result[i] = 'S'
-        when 'T', 't'
-          result[i] = 'T'
-        when 'U', 'u', 'Ù', 'Ú', 'Û', 'ù', 'ú', 'û'
-          result[i] = 'U'
-        when 'V', 'v'
-          result[i] = 'V'
-        when 'W', 'w'
-          result[i] = 'W'
-        when 'X', 'x'
-          result[i] = 'X'
-        when 'Y', 'y', 'Ü', 'Ý', 'ü', 'ý'
-          result[i] = 'Y'
-        when 'Z', 'z'
-          result[i] = 'Z'
-        when '[', 'Å', 'å'
-          result[i] = '['
-        when '\\', 'Ä', 'Æ', 'ä', 'æ'
-          result[i] = '\\'
-        when ']', 'Ö', 'ö'
-          result[i] = ']'
-        when 'Ø', 'ø'
-          result[i] = 'Ø'
-        when 'Þ', 'þ'
-          result[i] = 'Þ'
-        end
-      end
-      result
-    end
-  end
-end

data/lib/linkage/expectation.rb

@@ -1,21 +0,0 @@
-module Linkage
-  # The Expectation class contains information about how two datasets
-  # should be linked.
-  class Expectation
-    def kind
-      raise NotImplementedError
-    end
-
-    def apply_to(*args)
-      raise NotImplementedError
-    end
-
-    def decollation_needed?
-      false
-    end
-  end
-end
-
-Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "expectations", "*.rb"))).each do |filename|
-  require filename
-end

data/lib/linkage/expectations/exhaustive.rb

@@ -1,63 +0,0 @@
-module Linkage
-  module Expectations
-    class Exhaustive < Expectation
-      attr_reader :comparator, :threshold, :mode
-
-      def initialize(comparator, threshold, mode)
-        @comparator = comparator
-        @threshold = threshold
-        @mode = mode
-      end
-
-      def kind
-        if @kind.nil?
-          if @comparator.lhs_args.length != @comparator.rhs_args.length
-            @kind = :cross
-          else
-            @kind = :self
-            @comparator.lhs_args.each_with_index do |lhs_arg, index|
-              rhs_arg = @comparator.rhs_args[index]
-              if !lhs_arg.objects_equal?(rhs_arg)
-                @kind = :cross
-                break
-              end
-            end
-          end
-
-          # Check for dual-linkage.
-          if @kind == :cross
-            # Assume that all lhs arguments have the same dataset, as well
-            # as all the rhs arguments. Only check the first argument of each
-            # side.
-            lhs_arg = @comparator.lhs_args[0]
-            rhs_arg = @comparator.rhs_args[0]
-            if !lhs_arg.datasets_equal?(rhs_arg)
-              @kind = :dual
-            end
-          end
-        end
-        @kind
-      end
-
-      def apply_to(dataset, side)
-        exprs =
-          case side
-          when :lhs
-            comparator.lhs_args.collect { |arg| arg.to_expr.as(arg.name) }
-          when :rhs
-            comparator.rhs_args.collect { |arg| arg.to_expr.as(arg.name) }
-          end
-        dataset.select_more(*exprs)
-      end
-
-      def satisfied?(score)
-        case mode
-        when :equal
-          score == threshold
-        when :min
-          score >= threshold
-        end
-      end
-    end
-  end
-end

data/lib/linkage/expectations/simple.rb

@@ -1,168 +0,0 @@
-module Linkage
-  module Expectations
-    class Simple < Expectation
-      # The dataset this expectation applies to: `:lhs` or `:rhs`. This
-      # only applies to filter expectations.
-      # @return [Symbol]
-      attr_reader :side
-
-      attr_reader :meta_object_1, :meta_object_2, :operator
-
-      VALID_OPERATORS = [:==, :'!=', :>, :<, :>=, :<=]
-
-      # Automatically create an expectation type depending on the arguments.
-      #
-      # @param [Linkage::MetaObject] meta_object_1
-      # @param [Linkage::MetaObject] meta_object_2
-      # @param [Symbol] operator Valid operators: `:==`, `:'!='`, `:>`, `:<`, `:>=`, `:<=`
-      def self.create(meta_object_1, meta_object_2, operator)
-        klass =
-          if meta_object_1.static? && meta_object_2.static?
-            raise ArgumentError, "An expectation with two static objects is invalid"
-          elsif meta_object_1.static? || meta_object_2.static?
-            Filter
-          elsif meta_object_1.side == meta_object_2.side
-            if !meta_object_1.datasets_equal?(meta_object_2)
-              raise ArgumentError, "An expectation with two dynamic objects with the same side but different datasets is invalid"
-            end
-            Filter
-          elsif meta_object_1.objects_equal?(meta_object_2)
-            Self
-          elsif meta_object_1.datasets_equal?(meta_object_2)
-            Cross
-          else
-            Dual
-          end
-
-        klass.new(meta_object_1, meta_object_2, operator)
-      end
-
-      # Creates a new Simple.
-      #
-      # @param [Linkage::MetaObject] meta_object_1
-      # @param [Linkage::MetaObject] meta_object_2
-      # @param [Symbol] operator Valid operators: `:==`, `:'!='`, `:>`, `:<`, `:>=`, `:<=`
-      def initialize(meta_object_1, meta_object_2, operator)
-        @meta_object_1 = meta_object_1
-        @meta_object_2 = meta_object_2
-        @operator = operator
-
-        if !VALID_OPERATORS.include?(operator)
-          raise ArgumentError, "Invalid operator: #{operator.inspect}"
-        end
-
-        after_initialize
-      end
-
-      def same_except_side?(other)
-        other.is_a?(Simple) &&
-          operator == other.operator &&
-          meta_object_1.objects_equal?(other.meta_object_1) &&
-          meta_object_2.objects_equal?(other.meta_object_2)
-      end
-
-      def exactly!
-        function_1 = Function['binary'].new(@meta_object_1.object, :dataset => @meta_object_1.dataset)
-        function_2 = Function['binary'].new(@meta_object_2.object, :dataset => @meta_object_2.dataset)
-        @meta_object_1 = MetaObject.new(function_1, @meta_object_1.side)
-        @meta_object_2 = MetaObject.new(function_2, @meta_object_2.side)
-      end
-
-      # Display any warnings about this expectation.
-      def display_warnings
-      end
-
-      def decollation_needed?
-        merged_field.ruby_type[:type] == String && (
-          @meta_object_1.collation != @meta_object_2.collation ||
-          @meta_object_1.database_type != @meta_object_2.database_type
-        )
-      end
-
-      protected
-
-      def after_initialize
-      end
-    end
-
-    class Filter < Simple
-      def kind; :filter; end
-
-      def to_expr
-        case @operator
-        when :==, :'!='
-          expr = { @meta_object_1.to_expr => @meta_object_2.to_expr }
-          @operator == :== ? expr : ~expr
-        else
-          Sequel::SQL::BooleanExpression.new(@operator,
-            @meta_object_1.to_identifier, @meta_object_2.to_identifier)
-        end
-      end
-
-      def apply_to(dataset, side)
-        if side != @side
-          return dataset
-        end
-
-        dataset.filter(self.to_expr)
-      end
-
-      def decollation_needed?
-        false
-      end
-
-      private
-
-      def after_initialize
-        super
-        @side = @meta_object_1.static? ? @meta_object_2.side : @meta_object_1.side
-      end
-    end
-
-    class Match < Simple
-      def apply_to(dataset, side)
-        target =
-          if @meta_object_1.side == side
-            @meta_object_1
-          elsif @meta_object_2.side == side
-            @meta_object_2
-          else
-            raise ArgumentError, "Invalid `side` argument: #{side}"
-          end
-
-        dataset.group_match_more({
-          :meta_object => target,
-          :alias => merged_field.name
-        })
-      end
-
-      def merged_field
-        @merged_field ||= @meta_object_1.merge(@meta_object_2)
-      end
-
-      def display_warnings
-        object_1 = @meta_object_1.object
-        object_2 = @meta_object_2.object
-        if object_1.ruby_type[:type] == String && object_2.ruby_type[:type] == String
-          if @meta_object_1.dataset.database_type != @meta_object_2.dataset.database_type
-            warn "NOTE: You are comparing two string fields (#{object_1.name} and #{object_2.name}) from different databases. This may result in unexpected results, as different databases compare strings differently. Consider using the =binary= function."
-          elsif object_1.respond_to?(:collation) && object_1.respond_to?(:collation) && object_1.collation != object_2.collation
-            warn "NOTE: The two string fields you are comparing (#{object_1.name} and #{object_2.name}) have different collations (#{ldata.collation} vs. #{rdata.collation}). This may result in unexpected results, as the database may compare them differently. Consider using the =exactly= method."
-          end
-        end
-      end
-    end
-
-    class Self < Match
-      def kind; :self; end
-    end
-
-    class Cross < Match
-      def kind; :cross; end
-    end
-
-    class Dual < Match
-      def kind; :dual; end
-    end
-  end
-end

data/lib/linkage/function.rb

@@ -1,148 +0,0 @@
-module Linkage
-  # Abstract class to represent SQL functions. No attempts are made to
-  # ensure that the function actually exists in the database you're using.
-  #
-  # @abstract
-  class Function < Data
-    # Register a new function.
-    #
-    # @param [Class] klass Function class (probably a subclass of {Function})
-    def self.register(klass)
-      if klass.instance_methods(false).any? { |m| m.to_s == "ruby_type" }
-        @functions ||= {}
-        @functions[klass.function_name] = klass
-      else
-        raise ArgumentError, "ruby_type instance method must be defined"
-      end
-    end
-
-    def self.[](name)
-      @functions ? @functions[name] : nil
-    end
-
-    # Subclasses must define this.
-    def self.function_name
-      raise NotImplementedError
-    end
-
-    # Subclasses can define this to require a specific number of arguments
-    # of a certain class. To require two parameters of either String or
-    # Integer, do something like this:
-    #
-    #   @@parameters = [[String, Integer], [String, Integer]]
-    #   def self.parameters
-    #     @@parameters
-    #   end
-    #
-    def self.parameters
-      nil
-    end
-
-    attr_reader :args
-
-    # Creates a new Function object. If the arguments contain only
-    # static objects, you should specify the dataset that this function
-    # belongs to as the last argument like so:
-    #
-    #   Function.new(foo, bar, :dataset => dataset)
-    #
-    # Optionally, you can use the `dataset=` setter to do it later. Many
-    # functions require a dataset to work properly. If you try to use
-    # such a function without setting a  dataset, it will raise a RuntimeError.
-    #
-    # @param [Linkage::Data, Object] args Function arguments
-    def initialize(*args)
-      @names = [self.class.function_name]
-      @args = args
-      @options = args.last.is_a?(Hash) ? args.pop : {}
-      process_args
-    end
-
-    def name
-      @name ||= @names.join("_").to_sym
-    end
-
-    def dataset
-      if @dataset.nil?
-        raise RuntimeError, "You must specify a dataset for static functions"
-      end
-      @dataset
-    end
-
-    def dataset=(dataset)
-      @dataset = dataset
-    end
-
-    def static?
-      @static
-    end
-
-    def ==(other)
-      equal?(other) || (other.is_a?(Function) && name == other.name && args == other.args && dataset == other.dataset)
-    end
-
-    # Subclasses must define this. The return value should be a Hash with
-    # the following elements:
-    #   :type - column type (Ruby class) of the result
-    #   :opts - Optional hash with additional options (like :size)
-    def ruby_type
-      raise NotImplementedError
-    end
-
-    # Returns `nil` by default. Subclasses should redefine this if
-    # there is a collation.
-    def collation
-      nil
-    end
-
-    # @return [Sequel::SQL::Function]
-    def to_expr(options = {})
-      self.class.function_name.to_sym.sql_function(*@values)
-    end
-
-    private
-
-    def process_args
-      parameters = self.class.parameters
-      if parameters && parameters.length != @args.length
-        raise ArgumentError, "wrong number of arguments (#{@args.length} for #{parameters.length})"
-      end
-
-      @static = true
-      @values = []
-      @args.each_with_index do |arg, i|
-        if arg.kind_of?(Data)
-          @names << arg.name
-          @static &&= arg.static?
-
-          # possibly set dataset
-          if @dataset.nil?
-            @dataset = arg.dataset
-          elsif @dataset != arg.dataset
-            raise ArgumentError, "Using dynamic data sources with different datasets is not permitted"
-          end
-
-          type = arg.ruby_type[:type]
-          value = arg.to_expr
-        else
-          @names << arg.to_s.gsub(/\W/, "")
-          type = arg.class
-          value = arg
-        end
-        if parameters && parameters[i] != [:any] && !parameters[i].include?(type)
-          raise TypeError, "expected type #{parameters[i].join(" or ")}, got #{type}"
-        end
-        @values << value
-      end
-
-      if @dataset.nil? && @options[:dataset]
-        # Set dataset for static functions manually
-        @dataset = @options[:dataset]
-      end
-    end
-  end
-end
-
-Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "functions", "*.rb"))).each do |filename|
-  require filename
-end

data/lib/linkage/functions/binary.rb

@@ -1,30 +0,0 @@
-module Linkage
-  module Functions
-    class Binary < Function
-      def self.function_name
-        "binary"
-      end
-
-      def self.parameters
-        [[String]]
-      end
-
-      def ruby_type
-        {:type => File}
-      end
-
-      def to_expr(options = {})
-        expr =
-          case dataset.database_type
-          when :sqlite
-            @values[0].cast(:blob)
-          when :postgres
-            @values[0].cast(:bytea)
-          else
-            @values[0].cast(:binary)
-          end
-      end
-    end
-    Function.register(Binary)
-  end
-end

data/lib/linkage/functions/cast.rb

@@ -1,54 +0,0 @@
-module Linkage
-  module Functions
-    class Cast < Function
-      def self.function_name
-        "cast"
-      end
-
-      def self.parameters
-        [[:any], [String]]
-      end
-
-      def ruby_type
-        type =
-          case @values[1]
-          when 'integer'
-            Fixnum
-          when 'binary'
-            File
-          else
-            raise "unknown type: #{@values[1]}"
-          end
-
-        {:type => type}
-      end
-
-      def to_expr(options = {})
-        cast =
-          case @values[1]
-          when 'integer'
-            case dataset.database_type
-            when :sqlite, :postgres, :h2
-              :integer
-            when :mysql
-              :signed
-            end
-          when 'binary'
-            case dataset.database_type
-            when :sqlite
-              :blob
-            when :postgres
-              :bytea
-            when :mysql, :h2
-              :binary
-            end
-          end
-
-        if cast
-          @values[0].cast(cast)
-        end
-      end
-    end
-    Function.register(Cast)
-  end
-end

data/lib/linkage/functions/length.rb

@@ -1,29 +0,0 @@
-module Linkage
-  module Functions
-    # Returns the number of characters in a string.
-    class Length < Function
-      def self.function_name
-        "length"
-      end
-
-      def self.parameters
-        [[String]]
-      end
-
-      def ruby_type
-        {:type => Fixnum}
-      end
-
-      def to_expr(options = {})
-        expr =
-          case dataset.database_type
-          when :mysql, :postgres
-            :char_length.sql_function(@values[0])
-          else
-            :length.sql_function(@values[0])
-          end
-      end
-    end
-    Function.register(Length)
-  end
-end

data/lib/linkage/functions/strftime.rb

@@ -1,33 +0,0 @@
-module Linkage
-  module Functions
-    class Strftime < Function
-      def self.function_name
-        "strftime"
-      end
-
-      def self.parameters
-        [[Date, Time, DateTime], [String]]
-      end
-
-      def ruby_type
-        # TODO: string length needed
-        {:type => String}
-      end
-
-      def to_expr(options = {})
-        expr =
-          case dataset.database_type
-          when :mysql
-            :date_format.sql_function(*@values)
-          when :sqlite
-            :strftime.sql_function(@values[1], @values[0])
-          when :postgres
-            :to_char.sql_function(*@values)
-          else
-            :strftime.sql_function(@values[0], @values[1])
-          end
-      end
-    end
-    Function.register(Strftime)
-  end
-end

data/lib/linkage/functions/trim.rb

@@ -1,30 +0,0 @@
-module Linkage
-  module Functions
-    class Trim < Function
-      def self.function_name
-        "trim"
-      end
-
-      def self.parameters
-        [[String]]
-      end
-
-      def ruby_type
-        if @args[0].kind_of?(Data)
-          @args[0].ruby_type
-        else
-          {:type => String}
-        end
-      end
-
-      def collation
-        if @args[0].kind_of?(Data)
-          @args[0].collation
-        else
-          super
-        end
-      end
-    end
-    Function.register(Trim)
-  end
-end