typespec 0.0.0.0 → 0.1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 053cefb1c4de028a2d651f0af8680542f7a1cf68
-  data.tar.gz: 0175bebfa51927432371af08b47ef587afefa8da
+  metadata.gz: 89735c9c1f915fb52dcbbf55eb6d01875b4edac2
+  data.tar.gz: 63067969f72f7b18b3b129e58c78c128f025f36b
 SHA512:
-  metadata.gz: 108f33607e4f9b542ae474a88ec96dc35fd5ec8dec1dcfbf6674af45e9f031ca57717f9b8d200784181dce28194356bd72ee0476169bd91f778b6065105285f0
-  data.tar.gz: be222fb1d2ada94fddf77c75b7a02517e14ebf0c1cde2f7a36160cbbaf1f7e9875b46a13c4f377211f33a10745753d340a0bc382e01f58b672884fdca9ac6552
+  metadata.gz: b7414951bc78d23b602e6b5cabf7328c7da83bf72268f28fb824643aec3de3efb17f6425e415668b4284bc2629022f7355960e72fc70f8b224cbed5948f4d50d
+  data.tar.gz: 1b12cb00d9639a1ace0e92b16e71b7b8ed6a49c587b1e580b4f2fd4d7adac9acdb844f742e5d2fd31ec1b75580c2a23e5fa78332f334f6201fed56c969e37fdf

data/README.md

@@ -8,8 +8,29 @@
 :nut_and_bolt: Specify complex schema made of types or specific values.
 
 ```Ruby
-Typespec.hash[Typespec.string => Typespec.or[Typespec.nothing,
-                                             Typespec.boolean,
-                                             Typespec.number,
-                                             Typespec.string]]
+module Defines
+  def self.typespec
+    Typespec.hash[Typespec.string => Typespec.or[Typespec.nothing,
+                                                 Typespec.boolean,
+                                                 Typespec.number,
+                                                 Typespec.string]]
+  end
+end
+
+Defines.typespec.matches?('YETI_LINKAGE' => 'YETI_LINKAGE_STATIC',
+                          '__YETI_IS_BEING_COMPILED__' => true,
+                          'YETI_CONFIGURATION' => 'YETI_CONFIGURATION_DEBUG',
+                          '_HAS_EXCEPTIONS' => false,
+                          '_SCL_SECURE_NO_WARNINGS' => true,
+                          '_CRT_SECURE_NO_WARNINGS' => true,
+                          '_CRT_SECURE_NO_DEPRECATE' => true,
+                          '_SECURE_SCL_THROWS' => false,
+                          '_SILENCE_DEPRECATION_OF_SECURE_SCL_THROWS' => true,
+                          '_USING_V110_SDK71_' => true,
+                          '_DEBUG' => true,
+                          '_HAS_ITERATOR_DEBUGGING' => true,
+                          '_SECURE_SCL' => true)
+
+#=> true
 ```
+

data/lib/typespec.rb

@@ -1,2 +1,181 @@
+# ...
 module Typespec
+  # TODO(mtwilliams): Perform sanity checks.
+  # TODO(mtwilliams): Raise (custom) exceptions.
+  # TODO(mtwilliams): Explain the Type-Value-Or sysem.
+  # TODO(mtwilliams): Provide an example on how to rewrite exceptions.
+  # TODO(mtwilliams): Document this monstrosity.
+
+  # ...
+  def self.any; Typespec::Any; end
+
+  # ...
+  class Any
+    def self.valid?(_); true; end
+  end
+
+  # ...
+  def self.t; Typespec::Type; end
+
+  # ...
+  class Type
+    def initialize(type); @type = type; end
+    def self.[](type); self.new(type); end
+    def valid?(value); value.is_a?(@type); end
+  end
+
+  # ...
+  def self.expects; Typespec::Value; end
+
+  # ...
+  class Value
+    def initialize(value); @value = value; end
+    def self.[](value); self.new(value); end
+    def valid?(value) value.eql?(@value); end
+  end
+
+  # ...
+  def self.or; Typespec::Or; end
+
+  # ...
+  class Or
+    def initialize(expects); @expects = [*expects]; end
+    def valid?(value); @expects.any?{|expects| expects.valid?(value)}; end
+  end
+
+  # ...
+  def self.nil; Typespec.t[NilClass]; end
+
+  # ...
+  def self.boolean; Typespec.or[Typespec.t[TrueClass], Typespec.t[FalseClass]]; end
+
+  # ...
+  def self.number; Typespec.t[Numeric]; end
+
+  # ...
+  def self.integer; Typespec.t[Integer]; end
+
+  # ...
+  def self.float; Typespec.t[Float]; end
+
+  # ...
+  def self.rational; Typespec.t[Rational]; end
+
+  # ...
+  def self.string; Typespec.t[String]; end
+
+  # ...
+  def self.symbol; Typespec.t[Symbol]; end
+
+  # ...
+  def self.array; Typespec::Array; end
+
+  # ...
+  class Array
+    def initialize(*elements)
+      @element = Typespec.or[*elements]
+    end
+
+    def self.[](*elements)
+      Typespec::Array.new(*elements)
+    end
+
+    def valid?(value)
+      if value.is_a? Array
+        value.all?{|element| @element.valid?(element)}
+      else
+        false
+      end
+    end
+  end
+
+  # ...
+  def self.hash; Typespec::Hash; end
+
+  # ...
+  class Hash
+    def initialize(**pairs)
+      @pairs = pairs
+      @pairs ||= {Typespec.any => Typespec.any}
+    end
+
+    def self.[](**pairs)
+      Typespec::Hash.new(**pairs)
+    end
+
+    def valid?(value)
+      if value.is_a? Hash
+        value.all? do |k, v|
+          @pairs.any? do |pair|
+            pair.zip([k,v]).all? {|typespec, value| typespec.valid?(value)}
+          end
+        end
+      else
+        false
+      end
+    end
+  end
+
+  # ...
+  def self.struct; Typespec::Struct; end
+
+  # ...
+  class Struct
+    def initialize(*properties, **properties_with_spec)
+      if !properties.empty?
+        @properties = Hash[properties.map{|name| [name, Typespec.any]}]
+      elsif properties_with_spec
+        @properties = properties_with_spec
+      else
+        @properties = {}
+      end
+    end
+
+    def self.[](*properties, **properties_with_spec)
+      Typespec::Struct.new(*properties, **properties_with_spec)
+    end
+
+    def valid?(struct, opts={})
+      if struct.instance_of? Object
+        ignore_if_not_in_spec = opts.fetch(:ignore_if_not_in_spec, false)
+        struct.instance_variables.all? do |property|
+          undecorated = property.to_s[1..-1].to_sym
+          if @properties.include?(undecorated)
+            value = struct.instance_variable_get(property)
+            @properties[undecorated].valid?(value)
+          else
+            ignore_if_not_in_spec
+          end
+        end
+      else
+        false
+      end
+    end
+  end
+
+  # ...
+  def self.object; Typespec::Object; end
+
+  # ...
+  class Object < Struct
+    def self.[](*properties, **properties_with_spec)
+      Typespec::Object.new(*properties, **properties_with_spec)
+    end
+
+    def valid?(object, opts={})
+      super(object, opts.merge({:ignore_if_not_in_spec => true}))
+    end
+  end
+
+  # ...
+  def self.enum; Typespec::Enum; end
+
+  # ...
+  class Enum
+    def initialize(*can_take_on) @can_take_on = [*can_take_on] end
+    def self.[](*can_take_on); Typespec::Enum.new(can_take_on); end
+    def valid?(can_take_on) can_take_on.include?(@can_take_on); end
+  end
 end
+
+

data/lib/typespec/gem.rb

@@ -41,7 +41,7 @@ module Typespec
     end
 
     module VERSION #:nodoc:
-      MAJOR, MINOR, PATCH, PRE = [0, 0, 0, 0]
+      MAJOR, MINOR, PATCH, PRE = [0, 1, 0, 0]
       STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typespec
 version: !ruby/object:Gem::Version
-  version: 0.0.0.0
+  version: 0.1.0.0
 platform: ruby
 authors:
 - Michael Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-09 00:00:00.000000000 Z
+date: 2015-11-12 00:00:00.000000000 Z
 dependencies: []
 description: Typespec is a way to specify complex schema made of types or specific
   values and validate against them.