finitio 0.7.0.pre.rc2 → 0.9.0

data/lib/finitio/generation/ad_type.rb

@@ -0,0 +1,10 @@
+module Finitio
+  class AdType
+
+    def generate_data(generator, world = nil)
+      infotype = generator.flip_one_out_of(contracts).infotype
+      generator.call(infotype, world)
+    end
+
+  end # class AliasType
+end # module Finitio

data/lib/finitio/generation/alias_type.rb

@@ -0,0 +1,9 @@
+module Finitio
+  class AliasType
+
+    def generate_data(generator, world = nil)
+      generator.call(target, world)
+    end
+
+  end # class AliasType
+end # module Finitio

data/lib/finitio/generation/any_type.rb

@@ -0,0 +1,11 @@
+module Finitio
+  class AnyType
+
+    def generate_data(generator, world = nil)
+      candidates = [NilClass, String, Integer, Float]
+      type = generator.flip_one_out_of(candidates)
+      generator.heuristic.call(type, generator, world)
+    end
+
+  end # class AnyType
+end # module Finitio

data/lib/finitio/generation/builtin_type.rb

@@ -0,0 +1,9 @@
+module Finitio
+  class BuiltinType
+
+    def generate_data(generator, world = nil)
+      generator.heuristic.call(ruby_type, generator, world)
+    end
+
+  end # class BuiltinType
+end # module Finitio

data/lib/finitio/generation/hash_based_type.rb

@@ -0,0 +1,15 @@
+module Finitio
+  module HashBasedType
+
+    def generate_data(generator, world = nil)
+      tuple = {}
+      heading.each do |a|
+        if a.required or generator.flip_coin
+          tuple[a.name.to_sym] = generator.call(a.type, world)
+        end
+      end
+      tuple
+    end
+
+  end # class HashBasedType
+end # module Finitio

data/lib/finitio/generation/heuristic.rb

@@ -0,0 +1,8 @@
+module Finitio
+  class Generation
+    class Heuristic
+    end # class Heuristic
+  end # class Generation
+end # module Finitio
+require_relative "heuristic/constant"
+require_relative "heuristic/random"

data/lib/finitio/generation/heuristic/constant.rb

@@ -0,0 +1,30 @@
+module Finitio
+  class Generation
+    class Heuristic
+      class Constant < Heuristic
+
+        CONSTANTS = {
+          NilClass => nil,
+          TrueClass => true,
+          FalseClass => false,
+          Integer => 99,
+          Float => 99.99,
+          String => "Hello world",
+          Date => Date.today,
+          Time => Time.now,
+          DateTime => DateTime.now,
+        }
+
+        def call(ruby_type, generator, world = nil)
+          CONSTANTS.fetch(ruby_type) do
+            CONSTANTS.each_pair do |clazz, value|
+              return value if clazz >= ruby_type
+            end
+            throw :unfound
+          end
+        end
+
+      end # class Constant
+    end # class Heuristic
+  end # class Generation
+end # module Finition

data/lib/finitio/generation/heuristic/random.rb

@@ -0,0 +1,52 @@
+module Finitio
+  class Generation
+    class Heuristic
+      class Random < Heuristic
+
+        RANDOMERS = {
+          NilClass => nil,
+
+          TrueClass => true,
+
+          FalseClass => false,
+
+          Integer => ->(_,g,_) {
+            g.flip_one_out_of(1_000_000)
+          },
+
+          Float => ->(_,g,_) {
+            g.flip_one_out_of(1_000_000)            
+          },
+
+          String => ->(_,g,_) {
+            (1..3).map{ SecureRandom.hex(6) }.join(" ")
+          },
+
+          Date => ->(_,g,_) {
+            Time.at(rand * Time.now.to_i).to_date
+          },
+
+          Time => ->(_,g,_) {
+            Time.at(rand * Time.now.to_i)
+          },
+
+          DateTime => ->(_,g,_) {
+            Time.at(rand * Time.now.to_i).to_datetime
+          }
+        }
+
+        def call(ruby_type, generator, world = nil)
+          r = RANDOMERS.fetch(ruby_type) do
+            pair = RANDOMERS.find do |clazz, value|
+              clazz >= ruby_type
+            end
+            throw :unfound unless pair
+            pair.last
+          end
+          r.is_a?(Proc) ? r.call(ruby_type, generator, world) : r
+        end
+
+      end # class Random
+    end # class Heuristic
+  end # class Generation
+end # module Finition

data/lib/finitio/generation/rel_based_type.rb

@@ -0,0 +1,13 @@
+module Finitio
+  module RelBasedType
+
+    def generate_data(generator, world = nil)
+      coll = []
+      generator.collection_size.times do
+        coll << generator.call(tuple_type, world)
+      end
+      coll.uniq
+    end
+
+  end # module RelBasedType
+end # module Finitio

data/lib/finitio/generation/seq_type.rb

@@ -0,0 +1,13 @@
+module Finitio
+  class SeqType
+
+    def generate_data(generator, world = nil)
+      coll = []
+      generator.collection_size.times do
+        coll << generator.call(elm_type, world)
+      end
+      coll
+    end
+
+  end # class SeqType
+end # module Finitio

data/lib/finitio/generation/set_type.rb

@@ -0,0 +1,13 @@
+module Finitio
+  class SetType
+
+    def generate_data(generator, world = nil)
+      coll = []
+      generator.collection_size.times do
+        coll << generator.call(elm_type, world)
+      end
+      coll.uniq
+    end
+
+  end # class SetType
+end # module Finitio

data/lib/finitio/generation/sub_type.rb

@@ -0,0 +1,9 @@
+module Finitio
+  class SubType
+
+    def generate_data(generator, world = nil)
+      generator.call(super_type, world)
+    end
+
+  end # class SubType
+end # module Finitio

data/lib/finitio/generation/union_type.rb

@@ -0,0 +1,10 @@
+module Finitio
+  class UnionType
+
+    def generate_data(generator, world = nil)
+      picked = generator.flip_one_out_of(candidates)
+      generator.call(picked, world)
+    end
+
+  end # class UnionType
+end # module Finitio

data/lib/finitio/inference.rb

@@ -0,0 +1,51 @@
+module Finitio
+  class Inference
+
+    def initialize(system, options = {})
+      @system = system
+      @options = options
+    end
+    attr_reader :system
+
+    def call(input)
+      infer_type(input)
+    end
+
+  private
+
+    def infer_type(value)
+      case value
+      when Hash
+        attrs = value.map{|k,v|
+          Attribute.new(k.to_sym, infer_type(v))
+        }
+        heading = Heading.new(attrs)
+        TupleType.new(heading)
+      when Array
+        infered = value.inject(nil){|sup, value|
+          value_type = infer_type(value)
+          sup.nil? ? value_type : sup.suppremum(value_type)
+        }
+        SeqType.new(infered.nil? ? ANY_TYPE : infered)
+      else
+        found = self.system.types.values.find{|t|
+          try_dress(t, value)
+        }
+        found ? found : ANY_TYPE
+      end
+    end
+
+    def try_dress(t, value)
+      raise "Type expected, got #{t}" unless t.is_a?(Type)
+      t.dress(value)
+      true
+    rescue Finitio::Error => ex
+      #puts %Q{[#{ex.class}] #{ex.message}}
+      nil
+    rescue => ex
+      puts %Q{[#{ex.class}] #{ex.message}\n#{ex.backtrace.join("\n")}}
+      nil
+    end
+
+  end # class Inference
+end # module Finitio

data/lib/finitio/json_schema.rb

@@ -0,0 +1,16 @@
+module Finitio
+  module JsonSchema
+    class Error < Finitio::Error; end
+  end # module JsonSchema
+end # module Finitio
+require_relative 'json_schema/ad_type'
+require_relative 'json_schema/any_type'
+require_relative 'json_schema/alias_type'
+require_relative 'json_schema/builtin_type'
+require_relative 'json_schema/hash_based_type'
+require_relative 'json_schema/rel_based_type'
+require_relative 'json_schema/seq_type'
+require_relative 'json_schema/set_type'
+require_relative 'json_schema/struct_type'
+require_relative 'json_schema/sub_type'
+require_relative 'json_schema/union_type'

data/lib/finitio/json_schema/ad_type.rb

@@ -0,0 +1,11 @@
+module Finitio
+  class AdType
+
+    def to_json_schema(*args, &bl)
+      {
+        anyOf: contracts.map{|c| c.infotype.to_json_schema(*args, &bl) }
+      }
+    end
+
+  end # class AdType
+end # module Finitio

data/lib/finitio/json_schema/alias_type.rb

@@ -0,0 +1,9 @@
+module Finitio
+  class AliasType
+
+    def to_json_schema(*args, &bl)
+      target.to_json_schema(*args, &bl)
+    end
+
+  end # class AliasType
+end # module Finitio

data/lib/finitio/json_schema/any_type.rb

@@ -0,0 +1,9 @@
+module Finitio
+  class AnyType
+
+    def to_json_schema(*args, &bl)
+      {}
+    end
+
+  end # class AnyType
+end # module Finitio

data/lib/finitio/json_schema/builtin_type.rb

@@ -0,0 +1,27 @@
+module Finitio
+  module JsonSchema
+
+    BUILTIN_MAPPING = {
+      NilClass => "null",
+      String => "string",
+      Integer => "integer",
+      Fixnum => "integer",
+      Bignum => "integer",
+      Float => "number",
+      Numeric => "number"
+    }
+
+  end
+  class BuiltinType
+
+    def to_json_schema(*args, &bl)
+      mapped = JsonSchema::BUILTIN_MAPPING[ruby_type]
+      if mapped
+        { type: mapped }
+      else
+        raise JsonSchema::Error, "Unable to map #{ruby_type} to json-schema"
+      end
+    end
+
+  end # class BuiltinType
+end # module Finitio

data/lib/finitio/json_schema/hash_based_type.rb

@@ -0,0 +1,25 @@
+module Finitio
+  module HashBasedType
+
+    def to_json_schema(*args, &bl)
+      base = {
+        type: "object"
+      }
+      unless heading.empty?
+        base[:properties] = heading.inject({}){|ps,a|
+            ps.merge(a.name => a.type.to_json_schema(*args, &bl))
+        }
+      end
+      unless (reqs = heading.select{|a| a.required? }).empty?
+        base[:required] = reqs.map{|a| a.name }
+      end
+      base[:additionalProperties] = if heading.allow_extra?
+        heading.allow_extra.to_json_schema(*args, &bl)
+      else
+        false
+      end
+      base
+    end
+
+  end # module HashBasedType
+end # module UnionType

data/lib/finitio/json_schema/rel_based_type.rb

@@ -0,0 +1,13 @@
+module Finitio
+  module RelBasedType
+
+    def to_json_schema(*args, &bl)
+      {
+        type: "array",
+        items: tuple_type.to_json_schema(*args, &bl),
+        uniqueItems: true
+      }
+    end
+
+  end # module RelBasedType
+end # module Finitio

data/lib/finitio/json_schema/seq_type.rb

@@ -0,0 +1,12 @@
+module Finitio
+  class SeqType
+
+    def to_json_schema(*args, &bl)
+      {
+        type: "array",
+        items: elm_type.to_json_schema(*args, &bl)
+      }
+    end
+
+  end # class SeqType
+end # module Finitio

data/lib/finitio/json_schema/set_type.rb

@@ -0,0 +1,13 @@
+module Finitio
+  class SetType
+
+    def to_json_schema(*args, &bl)
+      {
+        type: "array",
+        items: elm_type.to_json_schema(*args, &bl),
+        uniqueItems: true
+      }
+    end
+
+  end # class SetType
+end # module Finitio

data/lib/finitio/json_schema/struct_type.rb

@@ -0,0 +1,12 @@
+module Finitio
+  class StructType
+
+    def to_json_schema(*args, &bl)
+      {
+        type: "array",
+        items: component_types.map{|c| c.to_json_schema(*args, &bl) }
+      }
+    end
+
+  end # class StructType
+end # module Finitio

data/lib/finitio/json_schema/sub_type.rb

@@ -0,0 +1,10 @@
+module Finitio
+  class SubType
+
+    def to_json_schema(*args, &bl)
+      # TODO: add support for constraints here...
+      super_type.to_json_schema(*args, &bl)
+    end
+
+  end # class SubType
+end # module Finitio