typed-class 0.5.0

data/lib/typed_class/attribute.rb

@@ -0,0 +1,30 @@
+module TypedClassInternal
+
+  class Attribute
+
+    attr_reader :name, :klass, :default
+
+    def initialize(name, klass, opts={})
+      @name = Util.assert_class(name, Symbol)
+      @klass = Util.assert_class(klass, Class)
+      @optional = opts.delete(:optional)
+      @default = Util.assert_class_or_nil(opts.delete(:default), @klass)
+
+      if !@default.nil?
+        Util.check_state(@optional.nil? || @optional,
+                         "Attribute for klass[%s] with name[%s] has a default - it MUST be optional[%s]" % [@klass, @name, @optional])
+        @optional = true
+      end
+      if @optional.nil?
+        @optional = false
+      end
+      Util.assert_empty_opts(opts)
+    end
+
+    def optional?
+      @optional
+    end
+
+  end
+
+end

data/lib/typed_class/instance_checks.rb

@@ -0,0 +1,14 @@
+module TypedClassInternal
+
+  # Here to facilitate better error messages
+  module InstanceChecks
+
+    def InstanceChecks.opts_must_be_a_hash(opts)
+      if !opts.is_a?(Hash)
+        raise "Expected a hash of name/value pairs but got an argument of type[%s]" % opts.class.name
+      end
+    end
+
+  end
+
+end

data/lib/typed_class/metadata.rb

@@ -0,0 +1,44 @@
+module TypedClassInternal
+
+  class Metadata
+
+    attr_reader :klass, :attributes, :after_initialize
+
+    def initialize(klass)
+      @klass = Util.assert_class(klass, Class)
+
+      @attributes = []
+      @after_initialize = []
+      @defaults = {}
+    end
+
+    def add_attribute(attribute)
+      Util.assert_class(attribute, TypedClassInternal::Attribute)
+
+      # We have to delete the attribute. In Ruby, the class can always
+      # be re-opened in which case it is possible to redefine a given
+      # field.
+      @attributes.delete_if { |a| a.name == attribute.name }
+
+      @attributes << attribute
+      if attribute.default
+        @defaults[attribute.name] = attribute.default
+      end
+    end
+
+    def add_after_initialize(block)
+      @after_initialize << block
+    end
+
+    def get_default(attr_name)
+      Util.assert_class(attr_name, Symbol)
+      @defaults[attr_name]
+    end
+
+    def klass_name
+      @klass.to_s
+    end
+
+  end
+
+end

data/lib/typed_class/option.rb

@@ -0,0 +1,13 @@
+module TypedClassInternal
+
+  class Option
+
+    attr_reader :klass
+
+    def initialize(klass)
+      @klass = ::TypedClassInternal::Util.assert_class(klass, Class)
+    end
+
+  end
+
+end

data/lib/typed_class/typed_class.rb

@@ -0,0 +1,125 @@
+class TypedClass
+
+  @@map = {}
+  @@metadata = nil
+
+  def after_initialize
+    metadata = @@map[self.class.to_s.to_sym]
+    ::TypedClassInternal::Util.check_state(metadata, "No metadata for class[%s]" % self.class)
+    metadata.after_initialize.each do |block|
+      instance_eval(&block)
+    end
+  end
+
+  def TypedClass.inherited(child)
+    ::TypedClassInternal::Util.assert_class(child, Class)
+    ::TypedClassInternal::Util.check_state(child.superclass == TypedClass,
+                                               "Class must extend TypedClass directly")
+    @@metadata = @@map[child.to_s.to_sym]
+    if @@metadata.nil?
+      @@map[child.to_s.to_sym] = @@metadata = TypedClassInternal::Metadata.new(child)
+    end
+  end
+
+  def TypedClass.after_initialize(&block)
+    ::TypedClassInternal::Util.check_not_nil(@@metadata, "metadata not defined")
+    @@metadata.add_after_initialize(block)
+    TypedClass.rewrite_constructor(@@metadata)
+  end
+
+  def TypedClass.field(attr_name, attr_klass, opts={})
+    ::TypedClassInternal::Util.check_not_nil(@@metadata, "metadata not defined")
+    ::TypedClassInternal::Util.assert_class(attr_name, Symbol)
+    default = opts.delete(:default)
+    ::TypedClassInternal::Util.assert_empty_opts(opts)
+
+    if attr_klass.is_a?(Class)
+      klass = attr_klass
+      optional = false
+    else
+      ::TypedClassInternal::Util.assert_class(attr_klass, ::TypedClassInternal::Option)
+      klass = attr_klass.klass
+      optional = true
+    end
+
+    if default
+      ::TypedClassInternal::Util.assert_class(default, klass)
+    end
+    ::TypedClassInternal::Util.check_state(default.nil? || optional,
+                                               "Required fields cannot have defaults. Class[%s] Field[%s] Default[%s]" % [klass.name, attr_name, default])
+
+    attr = ::TypedClassInternal::Attribute.new(attr_name, klass, :default => default, :optional => optional)
+    @@metadata.add_attribute(attr)
+    TypedClass.rewrite_constructor(@@metadata)
+  end
+
+  def TypedClass.get_default(klass, attr_name)
+    ::TypedClassInternal::Util.assert_class(klass, Class)
+    ::TypedClassInternal::Util.assert_class(attr_name, Symbol)
+    metadata = @@map[klass.to_s.to_sym]
+    ::TypedClassInternal::Util.check_state(metadata, "No metadata for klass[%s]" % klass)
+    metadata.get_default(attr_name)
+  end
+
+  def TypedClass.option(klass)
+    ::TypedClassInternal::Option.new(klass)
+  end
+
+  def TypedClass.rewrite_constructor(metadata)
+    s = TypedClass.constructor_string(metadata)
+    metadata.klass.class_eval s
+  end
+
+  def TypedClass.constructor_string(metadata)
+    ::TypedClassInternal::Util.assert_class(metadata, ::TypedClassInternal::Metadata)
+
+    required_params = []
+    init_body = ""
+    have_options = false
+
+    metadata.attributes.each do |attr|
+      if attr.optional?
+        have_options = true
+        init_body << "    @%s = ::TypedClassInternal::Util.assert_class_or_nil(opts.delete(:%s), %s)" % [attr.name, attr.name, attr.klass.to_s]
+      else
+        required_params << attr.name.to_s
+        init_body << "    @%s = ::TypedClassInternal::Util.assert_class(%s, %s)" % [attr.name, attr.name, attr.klass.to_s]
+      end
+
+      if metadata.get_default(attr.name)
+        init_body << " || ::TypedClass.get_default(%s, :%s)" % [metadata.klass.to_s, attr.name]
+      end
+      init_body << "\n"
+    end
+
+    s = ""
+    if !metadata.attributes.empty?
+      s = "  attr_reader :%s\n" % [metadata.attributes.map(&:name).join(", :")]
+    end
+
+    s << "  def initialize(%s" % [required_params.join(", ")]
+    if have_options
+      if !required_params.empty?
+        s << ", "
+      end
+      s << "opts={}"
+      init_body << "    ::TypedClassInternal::Util.assert_empty_opts(opts)\n"
+
+      assertion = "    ::TypedClassInternal::InstanceChecks.opts_must_be_a_hash(opts)\n"
+
+      init_body = "%s\n%s" % [assertion, init_body]
+    end
+    s << ")\n"
+
+    s << init_body
+
+    if !metadata.after_initialize.empty?
+      s << "    after_initialize\n"
+    end
+
+    s << "  end\n"
+
+    s
+  end
+
+end

data/lib/typed_class/util.rb

@@ -0,0 +1,50 @@
+module TypedClassInternal
+
+  module Util
+
+    # Throws an error if opts is not empty. Useful when parsing
+    # arguments to a function
+    def Util.assert_empty_opts(opts)
+      Util.check_state(opts.empty?,
+                       "Invalid opts: %s\n%s" % [opts.keys.inspect, opts.inspect])
+    end
+
+    def Util.assert_class(value, klass)
+      Util.check_not_nil(value, "Value cannot be nil")
+      Util.check_not_nil(klass, "Klass cannot be nil")
+      Util.check_state(value.is_a?(klass),
+                       "Value is of type[#{value.class}] - class[#{klass}] is required. value[#{value.inspect}]")
+      value
+    end
+
+    def Util.assert_class_or_nil(value, klass)
+      if !value.nil?
+        Util.assert_class(value, klass)
+      end
+      value
+    end
+
+    def Util.check_state(expression, error_message=nil)
+      if expression.nil? || !expression
+        raise error_message || "check_state failed"
+      end
+      nil
+    end
+
+    def Util.check_not_nil(reference, error_message=nil)
+      if reference.nil?
+        raise error_message || "argument cannot be nil"
+      end
+      reference
+    end
+
+    def Util.check_not_blank(reference, error_message=nil)
+      if reference.to_s.empty?
+        raise error_message || "argument cannot be blank"
+      end
+      reference
+    end
+
+  end
+
+end

data/lib/typed_class.rb

@@ -0,0 +1,10 @@
+module TypedClassInternal
+
+  require 'typed_class/attribute'
+  require 'typed_class/instance_checks'
+  require 'typed_class/metadata'
+  require 'typed_class/option'
+  require 'typed_class/util'
+  require 'typed_class/typed_class'
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: typed-class
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: 
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Michael Bryzek
+- Peter Bakhirev
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-08-07 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Allows you to define very simple classes with immutable variables, type safe constructors, and generated readers
+email: mbryzek@alum.mit.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/typed_class.rb
+- lib/typed_class/attribute.rb
+- lib/typed_class/instance_checks.rb
+- lib/typed_class/metadata.rb
+- lib/typed_class/option.rb
+- lib/typed_class/util.rb
+- lib/typed_class/typed_class.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/typed_class
+licenses: 
+- Apache License, Version 2.0
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: A DSL for defining very simple, strongly typed classes
+test_files: []
+