linkage 0.0.1 → 0.0.2

data/Gemfile

@@ -6,12 +6,13 @@ group :development do
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.6.4"
   gem "rcov", ">= 0"
-  gem "guard-test"
   gem "test-unit", "2.3.2"
   gem "mocha"
   gem "sqlite3"
   gem "yard"
   gem "rake"
   gem "versionomy"
-  gem "guard-yard", :platforms => :ruby_19
+  gem "mysql2"
+  gem 'pry'
+  gem 'rdiscount'
 end

data/Gemfile.lock

@@ -2,41 +2,49 @@ GEM
   remote: http://rubygems.org/
   specs:
     blockenspiel (0.4.3)
+    coderay (0.9.8)
     git (1.2.5)
-    guard (0.6.2)
-      thor (~> 0.14.6)
-    guard-test (0.3.0)
-      guard (>= 0.2.2)
-      test-unit (~> 2.2)
-    guard-yard (1.0.1)
-      guard (>= 0.2.2)
-      yard (>= 0.7.0)
     jeweler (1.6.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
-    mocha (0.9.12)
-    rake (0.9.2)
-    rcov (0.9.10)
-    sequel (3.26.0)
-    sqlite3 (1.3.3)
+    metaclass (0.0.1)
+    method_source (0.6.7)
+      ruby_parser (>= 2.3.1)
+    mocha (0.10.0)
+      metaclass (~> 0.0.1)
+    mysql2 (0.3.10)
+    pry (0.9.7.4)
+      coderay (~> 0.9.8)
+      method_source (~> 0.6.7)
+      ruby_parser (>= 2.3.1)
+      slop (~> 2.1.0)
+    rake (0.9.2.2)
+    rcov (0.9.11)
+    rdiscount (1.6.8)
+    ruby_parser (2.3.1)
+      sexp_processor (~> 3.0)
+    sequel (3.29.0)
+    sexp_processor (3.0.8)
+    slop (2.1.0)
+    sqlite3 (1.3.4)
     test-unit (2.3.2)
-    thor (0.14.6)
     versionomy (0.4.1)
       blockenspiel (>= 0.4.1)
-    yard (0.7.2)
+    yard (0.7.3)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 1.0.0)
-  guard-test
-  guard-yard
   jeweler (~> 1.6.4)
   mocha
+  mysql2
+  pry
   rake
   rcov
+  rdiscount
   sequel
   sqlite3
   test-unit (= 2.3.2)

data/Guardfile

@@ -1,7 +1,6 @@
 guard 'test' do
-  watch(%r{^lib/linkage/runner/([^/]+)\.rb$}) { |m| "test/unit/test_#{m[1]}_runner.rb" }
-  watch(%r{^lib/linkage/([^/]+)\.rb$}) { |m| "test/unit/test_#{m[1]}.rb" }
-  watch(%r{^test/unit/test_.+\.rb$})
+  watch(%r{^lib/linkage/([^/]+/)*([^/]+)\.rb$}) { |m| "test/unit/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/unit/([^/]+/)*test_.+\.rb$})
   watch(%r{^test/integration/test_.+\.rb$})
   watch('lib/linkage/configuration.rb') { "test/unit/test_dataset.rb" }
   watch('test/helper.rb')  { "test" }

data/Rakefile

@@ -42,7 +42,7 @@ end
 
 task :default => :test
 
-require 'rake/rdoctask'
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   version = File.exist?('VERSION') ? File.read('VERSION') : ""
 

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/linkage/configuration.rb

@@ -14,9 +14,9 @@ module Linkage
   class Configuration
     # @private
     class ExpectationWrapper
-      def initialize(type, field, config)
+      def initialize(type, data, config)
         @type = type
-        @field = field
+        @data = data
         @config = config
         @side = nil
         @forced_kind = nil
@@ -25,15 +25,15 @@ module Linkage
       Linkage::Expectation::VALID_OPERATORS.each do |op|
         define_method(op) do |other|
           case other
-          when FieldWrapper
-            @other = other.field
-            if other.side == @field.side
+          when DataWrapper
+            @other = other.data
+            if @other.static? || other.side == @data.side
               @forced_kind = :filter
-              @side = @field.side
+              @side = @data.side
             end
           else
             @other = other
-            @side = @field.side
+            @side = @data.side
           end
           add_expectation(op)
         end
@@ -43,19 +43,14 @@ module Linkage
 
       def add_expectation(operator)
         klass = Expectation.get(@type)
-        exp = klass.new(operator, @field.field, @other, @forced_kind)
+        exp = klass.new(operator, @data.data, @other, @forced_kind)
         @config.add_expectation(exp, @side)
       end
     end
 
     # @private
-    class FieldWrapper
-      attr_reader :field, :side
-      def initialize(field, side, config)
-        @field = field
-        @side = side
-        @config = config
-      end
+    class DataWrapper
+      attr_reader :data, :side
 
       def must
         ExpectationWrapper.new(:must, self, @config)
@@ -64,6 +59,41 @@ module Linkage
       def must_not
         ExpectationWrapper.new(:must_not, self, @config)
       end
+
+      def static?
+        false
+      end
+    end
+
+    # @private
+    class FunctionWrapper < DataWrapper
+      def initialize(klass, args, config)
+        @klass = klass
+        @args = args
+        @config = config
+
+        @side = args.inject(nil) do |side, arg|
+          if arg.kind_of?(DataWrapper)
+            raise "conflicting sides" if side && side != arg.side
+            arg.side
+          else
+            side
+          end
+        end
+      end
+
+      def data
+        @klass.new(*@args.collect { |arg| arg.kind_of?(DataWrapper) ? arg.data : arg })
+      end
+    end
+
+    # @private
+    class FieldWrapper < DataWrapper
+      def initialize(field, side, config)
+        @data = field
+        @side = side
+        @config = config
+      end
     end
 
     # @private
@@ -174,5 +204,15 @@ module Linkage
     def inspect
       to_s
     end
+
+    # For handling functions
+    def method_missing(name, *args, &block)
+      klass = Function[name.to_s]
+      if klass
+        FunctionWrapper.new(klass, args, self)
+      else
+        super
+      end
+    end
   end
 end

data/lib/linkage/data.rb

@@ -0,0 +1,171 @@
+module Linkage
+  # Superclass to {Field} and {Function}.
+  #
+  # @abstract
+  class Data
+    # A "tree" used to find compatible types.
+    TYPE_CONVERSION_TREE = {
+      TrueClass => [Integer],
+      Integer => [Bignum, Float],
+      Bignum => [BigDecimal],
+      Float => [BigDecimal],
+      BigDecimal => [String],
+      String => nil,
+      DateTime => nil,
+      Date => nil,
+      Time => nil,
+      File => nil
+    }
+
+    # @return [Symbol] This object's name
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def ruby_type
+      raise NotImplementedError
+    end
+
+    def dataset
+      raise NotImplementedError
+    end
+
+    def to_expr
+      raise NotImplementedError
+    end
+
+    # Create a data object that can hold data from two other fields. If the fields
+    # have different types, the resulting type is determined via a
+    # type-conversion tree.
+    #
+    # @param [Linkage::Data] other
+    # @return [Linkage::Field]
+    def merge(other, new_name = nil)
+      schema_1 = self.ruby_type
+      schema_2 = other.ruby_type
+      if schema_1 == schema_2
+        result = schema_1
+      else
+        type_1 = schema_1[:type]
+        opts_1 = schema_1[:opts] || {}
+        type_2 = schema_2[:type]
+        opts_2 = schema_2[:opts] || {}
+        result_type = type_1
+        result_opts = schema_1[:opts] ? schema_1[:opts].dup : {}
+
+        # type
+        if type_1 != type_2
+          result_type = first_common_type(type_1, type_2)
+        end
+
+        # text
+        if opts_1[:text] != opts_2[:text]
+          # This can only be of type String.
+          result_opts[:text] = true
+          result_opts.delete(:size)
+        end
+
+        # size
+        if !result_opts[:text] && opts_1[:size] != opts_2[:size]
+          types = [type_1, type_2].uniq
+          if types.length == 1 && types[0] == BigDecimal
+            # Two decimals
+            if opts_1.has_key?(:size) && opts_2.has_key?(:size)
+              s_1 = opts_1[:size]
+              s_2 = opts_2[:size]
+              result_opts[:size] = [ s_1[0] > s_2[0] ? s_1[0] : s_2[0] ]
+
+              if s_1[1] && s_2[1]
+                result_opts[:size][1] = s_1[1] > s_2[1] ? s_1[1] : s_2[1]
+              else
+                result_opts[:size][1] = s_1[1] ? s_1[1] : s_2[1]
+              end
+            else
+              result_opts[:size] = opts_1.has_key?(:size) ? opts_1[:size] : opts_2[:size]
+            end
+          elsif types.include?(String) && types.include?(BigDecimal)
+            # Add one to the precision of the BigDecimal (for the dot)
+            if opts_1.has_key?(:size) && opts_2.has_key?(:size)
+              s_1 = opts_1[:size].is_a?(Array) ? opts_1[:size][0] + 1 : opts_1[:size]
+              s_2 = opts_2[:size].is_a?(Array) ? opts_2[:size][0] + 1 : opts_2[:size]
+              result_opts[:size] = s_1 > s_2 ? s_1 : s_2
+            elsif opts_1.has_key?(:size)
+              result_opts[:size] = opts_1[:size].is_a?(Array) ? opts_1[:size][0] + 1 : opts_1[:size]
+            elsif opts_2.has_key?(:size)
+              result_opts[:size] = opts_2[:size].is_a?(Array) ? opts_2[:size][0] + 1 : opts_2[:size]
+            end
+          else
+            # Treat as two strings
+            if opts_1.has_key?(:size) && opts_2.has_key?(:size)
+              result_opts[:size] = opts_1[:size] > opts_2[:size] ? opts_1[:size] : opts_2[:size]
+            elsif opts_1.has_key?(:size)
+              result_opts[:size] = opts_1[:size]
+            else
+              result_opts[:size] = opts_2[:size]
+            end
+          end
+        end
+
+        # fixed
+        if opts_1[:fixed] != opts_2[:fixed]
+          # This can only be of type String.
+          result_opts[:fixed] = true
+        end
+
+        result = {:type => result_type}
+        result[:opts] = result_opts  unless result_opts.empty?
+      end
+
+      if new_name
+        name = new_name.to_sym
+      else
+        name = self.name == other.name ? self.name : :"#{self.name}_#{other.name}"
+      end
+      Field.new(name, nil, result)
+    end
+
+    # Returns true if this data's name and dataset match the other's name
+    # and dataset (using {Dataset#==})
+    def ==(other)
+      if !other.is_a?(self.class)
+        super
+      elsif equal?(other)
+        true
+      else
+        self.name == other.name && self.dataset == other.dataset
+      end
+    end
+
+    # Returns true if this data source's dataset is equal to the given dataset
+    # (using Dataset#id).
+    #
+    # @param [Linkage::Dataset]
+    def belongs_to?(dataset)
+      self.dataset.id == dataset.id
+    end
+
+    private
+
+    def first_common_type(type_1, type_2)
+      types_1 = [type_1] + get_types(type_1)
+      types_2 = [type_2] + get_types(type_2)
+      (types_1 & types_2).first
+    end
+
+    # Get all types that the specified type can be converted to. Order
+    # matters.
+    def get_types(type)
+      result = []
+      types = TYPE_CONVERSION_TREE[type]
+      if types
+        result += types
+        types.each do |t|
+          result |= get_types(t)
+        end
+      end
+      result
+    end
+  end
+end

data/lib/linkage/dataset.rb

@@ -89,25 +89,25 @@ module Linkage
       })
     end
 
-    # Add a field to use for ordering the dataset.
+    # Add a data source to use for ordering the dataset.
     #
-    # @param [Linkage::Field] field
+    # @param [Linkage::Data] data
     # @param [nil, Symbol] desc nil or :desc (for descending order)
-    def add_order(field, desc = nil)
-      expr = desc == :desc ? field.name.desc : field.name
+    def add_order(data, desc = nil)
+      expr = desc == :desc ? data.to_expr.desc : data.to_expr
       unless @order.include?(expr)
         @order << expr
       end
     end
 
-    # Add a field to be selected on the dataset. If you don't add any
-    # selects, all fields will be selected. The primary key is always
-    # selected in either case.
+    # Add a data source to be selected on the dataset. If you don't add any
+    # selects, all fields will be selected. The primary key is always selected
+    # in either case.
     #
-    # @param [Linkage::Field] field
-    # @param [Symbol] as Optional field alias
-    def add_select(field, as = nil)
-      expr = as ? field.name.as(as) : field.name
+    # @param [Linkage::Data] data
+    # @param [Symbol] as Optional field/function alias
+    def add_select(data, as = nil)
+      expr = as ? data.to_expr.as(as) : data.to_expr
       unless @select.include?(expr)
         @select << expr
       end
@@ -115,12 +115,12 @@ module Linkage
 
     # Add a filter (SQL WHERE) condition to the dataset.
     #
-    # @param [Linkage::Field] field
+    # @param [Linkage::Data] data
     # @param [Symbol] operator
-    # @param [Linkage::Field, Object] other
-    def add_filter(field, operator, other)
-      arg1 = field.name
-      arg2 = other.is_a?(Field) ? other.name : other
+    # @param [Linkage::Data, Object] other
+    def add_filter(data, operator, other)
+      arg1 = data.to_expr
+      arg2 = other.is_a?(Data) ? other.to_expr : other
       expr =
         case operator
         when :==

data/lib/linkage/expectation.rb

@@ -9,13 +9,13 @@ module Linkage
     attr_reader :operator, :field_1, :field_2
 
     # @param [Symbol] operator Currently, only :==
-    # @param [Linkage::Field, Object] field_1
-    # @param [Linkage::Field, Object] field_2
+    # @param [Linkage::Field, Linkage::Function, Object] field_1
+    # @param [Linkage::Field, Linkage::Function, Object] field_2
     # @param [Symbol] force_kind Manually set type of expectation (useful for
     #   a filter between two fields)
     def initialize(operator, field_1, field_2, force_kind = nil)
-      if !(field_1.is_a?(Field) || field_2.is_a?(Field))
-        raise ArgumentError, "You must have at least one Linkage::Field"
+      if !((field_1.kind_of?(Data) && !field_1.static?) || (field_2.kind_of?(Data) && !field_2.static?))
+        raise ArgumentError, "You must have at least one data source (Linkage::Field or Linkage::Function)"
       end
 
       if !VALID_OPERATORS.include?(operator)
@@ -52,7 +52,7 @@ module Linkage
     # @return [Symbol] :self, :dual, :cross, or :filter
     def kind
       @kind ||=
-        if !(@field_1.is_a?(Field) && @field_2.is_a?(Field))
+        if !(@field_1.is_a?(Data) && !@field_1.static? && @field_2.is_a?(Data) && !@field_2.static?)
           :filter
         elsif @field_1 == @field_2
           :self
@@ -95,7 +95,7 @@ module Linkage
       else
         as =
           if kind == :self
-            nil
+            @field_1.is_a?(Function) ? @field_1.name : nil
           else
             name != @field_1.name ? name : nil
           end

data/lib/linkage/field.rb

@@ -1,24 +1,7 @@
 module Linkage
   # This class is for holding information about a particular field in a
   # dataset.
-  class Field
-    # A "tree" used to find compatible types.
-    TYPE_CONVERSION_TREE = {
-      TrueClass => [Integer],
-      Integer => [Bignum, Float],
-      Bignum => [BigDecimal],
-      Float => [BigDecimal],
-      BigDecimal => [String],
-      String => nil,
-      DateTime => nil,
-      Date => nil,
-      Time => nil,
-      File => nil
-    }
-
-    # @return [Symbol] This field's name
-    attr_reader :name
-
+  class Field < Data
     # @return [Symbol] This field's schema information
     attr_reader :schema
 
@@ -90,138 +73,16 @@ module Linkage
       @ruby_type
     end
 
-    # Create a field that can hold data from two other fields. If the fields
-    # have different types, the resulting type is determined via a
-    # type-conversion tree.
-    #
-    # @param [Linkage::Field] other
-    # @return [Linkage::Field]
-    def merge(other, new_name = nil)
-      schema_1 = self.ruby_type
-      schema_2 = other.ruby_type
-      if schema_1 == schema_2
-        result = schema_1
-      else
-        type_1 = schema_1[:type]
-        opts_1 = schema_1[:opts] || {}
-        type_2 = schema_2[:type]
-        opts_2 = schema_2[:opts] || {}
-        result_type = type_1
-        result_opts = schema_1[:opts] ? schema_1[:opts].dup : {}
-
-        # type
-        if type_1 != type_2
-          result_type = first_common_type(type_1, type_2)
-        end
-
-        # text
-        if opts_1[:text] != opts_2[:text]
-          # This can only be of type String.
-          result_opts[:text] = true
-          result_opts.delete(:size)
-        end
-
-        # size
-        if !result_opts[:text] && opts_1[:size] != opts_2[:size]
-          types = [type_1, type_2].uniq
-          if types.length == 1 && types[0] == BigDecimal
-            # Two decimals
-            if opts_1.has_key?(:size) && opts_2.has_key?(:size)
-              s_1 = opts_1[:size]
-              s_2 = opts_2[:size]
-              result_opts[:size] = [ s_1[0] > s_2[0] ? s_1[0] : s_2[0] ]
-
-              if s_1[1] && s_2[1]
-                result_opts[:size][1] = s_1[1] > s_2[1] ? s_1[1] : s_2[1]
-              else
-                result_opts[:size][1] = s_1[1] ? s_1[1] : s_2[1]
-              end
-            else
-              result_opts[:size] = opts_1.has_key?(:size) ? opts_1[:size] : opts_2[:size]
-            end
-          elsif types.include?(String) && types.include?(BigDecimal)
-            # Add one to the precision of the BigDecimal (for the dot)
-            if opts_1.has_key?(:size) && opts_2.has_key?(:size)
-              s_1 = opts_1[:size].is_a?(Array) ? opts_1[:size][0] + 1 : opts_1[:size]
-              s_2 = opts_2[:size].is_a?(Array) ? opts_2[:size][0] + 1 : opts_2[:size]
-              result_opts[:size] = s_1 > s_2 ? s_1 : s_2
-            elsif opts_1.has_key?(:size)
-              result_opts[:size] = opts_1[:size].is_a?(Array) ? opts_1[:size][0] + 1 : opts_1[:size]
-            elsif opts_2.has_key?(:size)
-              result_opts[:size] = opts_2[:size].is_a?(Array) ? opts_2[:size][0] + 1 : opts_2[:size]
-            end
-          else
-            # Treat as two strings
-            if opts_1.has_key?(:size) && opts_2.has_key?(:size)
-              result_opts[:size] = opts_1[:size] > opts_2[:size] ? opts_1[:size] : opts_2[:size]
-            elsif opts_1.has_key?(:size)
-              result_opts[:size] = opts_1[:size]
-            else
-              result_opts[:size] = opts_2[:size]
-            end
-          end
-        end
-
-        # fixed
-        if opts_1[:fixed] != opts_2[:fixed]
-          # This can only be of type String.
-          result_opts[:fixed] = true
-        end
-
-        result = {:type => result_type}
-        result[:opts] = result_opts  unless result_opts.empty?
-      end
-
-      if new_name
-        name = new_name.to_sym
-      else
-        name = self.name == other.name ? self.name : :"#{self.name}_#{other.name}"
-      end
-      Field.new(name, nil, result)
-    end
-
-    # Returns true if this field's name and dataset match the other's name
-    # and dataset (using {Dataset#==})
-    def ==(other)
-      if !other.is_a?(Field)
-        super
-      else
-        self.name == other.name && self.dataset == other.dataset
-      end
+    def to_expr
+      @name
     end
 
-    # Returns true if this field's dataset is equal to the given dataset
-    # (using Dataset#id).
-    #
-    # @param [Linkage::Dataset]
-    def belongs_to?(dataset)
-      self.dataset.id == dataset.id
+    def static?
+      false
     end
 
     def primary_key?
       schema && schema[:primary_key]
     end
-
-    private
-
-    def first_common_type(type_1, type_2)
-      types_1 = [type_1] + get_types(type_1)
-      types_2 = [type_2] + get_types(type_2)
-      (types_1 & types_2).first
-    end
-
-    # Get all types that the specified type can be converted to. Order
-    # matters.
-    def get_types(type)
-      result = []
-      types = TYPE_CONVERSION_TREE[type]
-      if types
-        result += types
-        types.each do |t|
-          result |= get_types(t)
-        end
-      end
-      result
-    end
   end
 end