finitio 0.7.0.pre.rc4 → 0.10.0

data/lib/finitio.rb

@@ -16,16 +16,18 @@ module Finitio
 
   ANY_TYPE = AnyType.new
 
+  LOCK = Mutex.new
+
   STDLIB_PATHS = [
     File.expand_path('../finitio/stdlib', __FILE__)
   ]
 
   MEMOIZED_SYSTEMS = {}
 
-  MEMOIZATION_SEMAPHORE = Mutex.new
-
   def stdlib_path(path)
-    STDLIB_PATHS << path
+    LOCK.synchronize {
+      STDLIB_PATHS << path
+    }
   end
 
   def parse(source)
@@ -33,7 +35,7 @@ module Finitio
   end
 
   def system(source)
-    MEMOIZATION_SEMAPHORE.synchronize {
+    LOCK.synchronize {
       _system(source)
     }
   end
@@ -48,7 +50,7 @@ module Finitio
   private :_system
 
   def clear_saved_systems!
-    MEMOIZATION_SEMAPHORE.synchronize {
+    LOCK.synchronize {
       MEMOIZED_SYSTEMS.clear
     }
   end

data/lib/finitio/generation.rb

@@ -0,0 +1,106 @@
+require 'securerandom'
+require_relative 'generation/heuristic'
+module Finitio
+  #
+  # This class helps generating random data for a given Finitio type.
+  #
+  # Example
+  #
+  #     type = Finitio.system(<<-FIO)
+  #       .Integer
+  #     FIO
+  #     gen = Finitio::Generation.new
+  #     gen.call(type)
+  #
+  # Random data is generated for most ruby builtin types, tuples and all sorts
+  # of collections (seq, set, relations).
+  #
+  # You can fine-tune the random data generation through the following means
+  # (the first one wins):
+  #
+  # * By passing generators by type name at construction:
+  #
+  #       Finition::Generation.new({
+  #         generators: {
+  #           "Name" => ->(type, g, world) { "Bernard" }
+  #         }
+  #       })
+  #
+  # * Through `examples` metadata put on type definitions:
+  #
+  #       /- examples: {"Bernard"} -/
+  #       Name = .String
+  #
+  class Generation
+
+    DEFAULT_OPTIONS = {
+
+      heuristic: Heuristic::Random.new,
+
+      collection_size: 1..10,
+
+      generators: {
+        "Date"     => ->(t,g,w) { g.heuristic.call(Date, g, w) },
+        "Time"     => ->(t,g,w) { g.heuristic.call(Time, g, w) },
+        "DateTime" => ->(t,g,w) { g.heuristic.call(DateTime, g, w) }
+      }
+
+    }
+
+    def initialize(options = {})
+      @options = DEFAULT_OPTIONS.merge(options){|k,v1,v2|
+        v1.is_a?(Hash) ? v1.merge(v2) : v2
+      }
+    end
+    attr_reader :options
+
+    def heuristic
+      options[:heuristic]
+    end
+
+    def generators
+      options[:generators]
+    end
+
+    def flip_coin
+      flip_one_out_of(2) == 1
+    end
+
+    def flip_one_out_of(n)
+      case n
+      when Integer    then Kernel.rand(n)
+      when Range      then Kernel.rand(n)
+      when Enumerable then n[flip_one_out_of(n.size)]
+      else
+        raise "Cannot flip one on #{n}"
+      end
+    end
+
+    def collection_size
+      size = options[:collection_size]
+      size = size.is_a?(Proc) ? size.call : size
+      flip_one_out_of(size)
+    end
+
+    def call(type, world = nil)
+      if gen = generators[type.name]
+        gen.call(type, self, world)
+      elsif exs = type.metadata && type.metadata[:examples]
+        flip_one_out_of(exs)
+      else
+        type.generate_data(self, world)
+      end
+    end
+
+  end # class Generation
+end # module Finitio
+require_relative 'generation/any_type'
+require_relative 'generation/builtin_type'
+require_relative 'generation/seq_type'
+require_relative 'generation/set_type'
+require_relative 'generation/hash_based_type'
+require_relative 'generation/rel_based_type'
+require_relative 'generation/union_type'
+require_relative 'generation/alias_type'
+require_relative 'generation/sub_type'
+require_relative 'generation/ad_type'

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