safe-me 0.9.0

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 Dario Rexin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,91 @@
+= safe-me
+
+* http://github.com/drexin/safe-me
+
+== Description:
+
+Add typechecking whenever you need it, without messing up your class files.
+
+== Install
+	
+  sudo gem install safe-me
+
+== Usage
+
+  require 'safe-me'
+
+If you don't use safe-me with rails you have to manually call
+  
+  SafeMe.init
+
+The declaration files have to be put in a folder called 'safe' in the app's root. 
+The naming convention for those files is 'class_name_safe.rb'. SafeMe automatically
+loads and evaluates those files on the call of SafeMe.init.
+
+== DSL
+
+The DSL ist very simple. Let me explain on an example:
+
+  #safe Class tells SafeMe which class it should work on
+  #be sure to have the class in scope
+  safe Foo do
+  
+    #for_method takes the name of the method to be made safe
+    #as symbol
+    for_method :a_method do
+      
+      #for each argument the method takes, you have to call argument
+      #with the type as parameter
+      argument Integer
+    end  
+  end
+  
+For now there are 4 kinds of possible argument types.
+
+- Classes
+
+You can simply pass a class as type to the argument call. There are some special cases:
+
+VarArgs: if you have a method with varargs, you have to have to pass VarArgs.ofType(Class) as the type
+Array: if you want type safe arrays, you can pass Array.ofType(Class)
+Hash: for hashes you can pass Hash.ofType(Class, Class) where the first class is for the key and the second for the value
+
+- Nilable
+
+If you also want to be able to pass nil to a method, if the argument is optional for example, you can pass nilable(Class) as type
+
+- RespondsTo
+
+If you only want to be sure, that an argument responds to some methods you can pass responds_to(*methods) where *methods should be the method names as symbols
+
+
+- QuacksLike
+
+If you need the same responds_to on multiple methods it can be useful to create a clean room class, that contains those methods and call quacks_like(Class) instead.
+quacks_like ensures, that every public instance method of this class is also available on the object, that gets passed to the method
+
+
+== License:
+
+The MIT License
+
+Copyright (c) 2010 Dario Rexin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,23 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+
+Rake::RDocTask.new do |rdoc|
+  files =['LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.title = "safe-me Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.rspec_opts = ["--color"]
+end

data/lib/extensions/array.rb

@@ -0,0 +1,34 @@
+require 'safe-me/var_args'
+
+Array.class_eval do
+
+  class ArrayType
+    def initialize type
+      @type = type
+    end
+
+    def is_type_of? obj
+      obj.kind_of? @type
+    end
+
+    def to_s
+      "Array[#{@type}]"
+    end
+  end
+
+  alias_method :orig_kind_of?, :kind_of?
+
+  def kind_of? type
+    if type.kind_of?(ArrayType) or type.kind_of?(VarArgs)
+      self.each do |e|
+        return false if not type.is_type_of?(e)
+      end
+    else
+      orig_kind_of? type
+    end
+  end
+  
+  def self.ofType type
+    ArrayType.new type
+  end
+end

data/lib/extensions/class.rb

@@ -0,0 +1,5 @@
+class Class
+  def type_of? obj
+    obj.kind_of? self
+  end
+end

data/lib/extensions/hash.rb

@@ -0,0 +1,34 @@
+require 'extensions/module'
+
+Hash.class_eval do
+  class HashType
+    def initialize key_type, value_type
+      @key_type = key_type
+      @value_type = value_type
+    end
+
+    def is_type_of? k, v
+      k.kind_of?(@key_type) and v.kind_of?(@value_type)
+    end
+
+    def to_s
+      "Hash[#{@key_type}, #{@value_type}]"
+    end
+  end
+
+  alias_method :orig_kind_of?, :kind_of?
+
+  def kind_of? type
+    if type.kind_of? HashType
+      self.each do |k,v|
+        return false if not type.is_type_of?(k, v)
+      end
+    else
+      orig_kind_of? type
+    end
+  end
+
+  def self.ofType key_type, value_type
+    HashType.new key_type, value_type
+  end
+end

data/lib/extensions/module.rb

@@ -0,0 +1,19 @@
+require 'safe-me/var_args'
+
+class Module
+  attr_accessor :method_types
+  def safe_method(name, safer)
+    alias_method "__typeunsafe_#{name}__", name
+    module_eval do
+      method_types = {} if method_types.nil?
+      method_types[name] = safer
+      define_method name do |*args, &block|
+        method_types[name].check(*args)
+        send(:"__typeunsafe_#{name}__",*args,&block)
+      end
+      alias_method "__typesafe_#{name}__", name
+    end
+  end
+
+  private :safe_method
+end

data/lib/safe-me.rb

@@ -0,0 +1,23 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+require 'safe-me/var_args'
+require 'safe-me/version'
+require 'safe-me/safe_loader'
+require 'extensions/module'
+require 'extensions/class'
+require 'extensions/hash'
+require 'extensions/array'
+
+if defined?(Rails)
+  require 'safe-me/rails'
+end
+
+module SafeMe
+  def self.init
+    Dir.glob("safe/*_safe.rb").each do |f|
+      SafeLoader.instance_eval File.read(f)
+    end
+  end
+end

data/lib/safe-me/duck_type.rb

@@ -0,0 +1,18 @@
+module SafeMe
+  class DuckType
+    def initialize type
+      @type = type
+    end
+  
+    def type_of? obj
+      @type.public_instance_methods.each do |m|
+        return false unless obj.class.public_instance_methods.include? m
+      end
+      true
+    end
+  
+    def to_s
+      "QuacksLike(#{@type})"
+    end
+  end
+end

data/lib/safe-me/nilable_type.rb

@@ -0,0 +1,15 @@
+module SafeMe
+  class NilableType
+    def initialize type
+      @type = type
+    end
+  
+    def type_of? obj
+      obj.nil? or obj.kind_of?(@type)
+    end
+  
+    def to_s
+      "#{@type} or nil"
+    end
+  end
+end

data/lib/safe-me/rails.rb

@@ -0,0 +1,9 @@
+module SafeMe
+  module Rails
+    class Railtie < ::Rails::Railtie
+      config.after_initialize do
+        SafeMe.init
+      end
+    end
+  end
+end

data/lib/safe-me/responds_to.rb

@@ -0,0 +1,18 @@
+module SafeMe
+  class RespondsTo
+    def initialize *methods
+      @methods = methods
+    end
+  
+    def type_of? obj
+      @methods.each do |m|
+        return false unless obj.respond_to? m
+      end
+      true
+    end
+  
+    def to_s
+      "RespondsTo(#{@methods.join(', ')})"
+    end
+  end
+end

data/lib/safe-me/safe_loader.rb

@@ -0,0 +1,22 @@
+require 'safe-me/type_safer'
+
+module SafeMe
+  module SafeLoader
+    def self.safe klass, &block
+      m = Methods.new klass
+      m.instance_eval &block
+    end
+  
+    class Methods
+      def initialize klass
+        @klass = klass
+      end
+    
+      def for_method name, &block
+        @klass.class_eval do
+          safe_method(name, TypeSafer.new(&block))
+        end
+      end
+    end
+  end
+end

data/lib/safe-me/type_safer.rb

@@ -0,0 +1,41 @@
+require 'safe-me/duck_type'
+require 'safe-me/nilable_type'
+require 'safe-me/responds_to'
+
+module SafeMe
+  class TypeSafer
+  
+    def initialize &block
+      @types = []
+      instance_eval &block
+    end
+    
+    def check *args
+      tmp = args
+      if @types.last.kind_of?(VarArgs)
+        tmp = args.slice(0, @types.size-1) + [args.slice(@types.size-1,args.size)]
+      end
+      tmp.size.times do |i|
+        raise ArgumentError.new("for argument #{i+1} expected type #{@types[i]}") unless  @types[i].type_of?(tmp[i])
+      end
+    end
+  
+    def argument type
+      @types << type
+    end
+
+    def quacks_like type
+      DuckType.new type
+    end
+  
+    def nilable type
+      NilableType.new type
+    end
+    
+    def responds_to *methods
+      RespondsTo.new *methods
+    end
+  
+    private :quacks_like, :argument
+  end
+end

data/lib/safe-me/var_args.rb

@@ -0,0 +1,20 @@
+
+class VarArgs
+
+  def is_type_of? obj
+    obj.kind_of? @type
+  end
+
+  def self.ofType type
+    self.new(type)
+  end
+
+  def to_s
+    "VarArgs[#{@type}]"
+  end
+
+  private
+  def initialize type
+    @type = type
+  end
+end

data/lib/safe-me/version.rb

@@ -0,0 +1,6 @@
+module SafeMe
+  unless defined?(SafeMe::VERSION)
+    VERSION       = '0.9.0'
+    LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+  end
+end

data/safe/Foo_safe.rb

@@ -0,0 +1,20 @@
+require 'spec/classes/foo'
+
+safe Foo do
+  for_method :a_method do
+    argument quacks_like(Integer)
+    argument quacks_like(Integer)
+  end
+  
+  for_method :another_method do
+    argument nilable(Integer)
+  end
+  
+  for_method :give_string do
+    argument String
+  end
+  
+  for_method :baz do
+    argument responds_to :bar
+  end
+end

data/spec/classes/Foo.rb

@@ -0,0 +1,17 @@
+class Foo
+  def a_method a, b
+    "#{a} and #{b} should both be integers."
+  end
+  
+  def another_method a
+    "#{a} should be an integer or nil."
+  end
+  
+  def give_string s
+    "#{s} should be a string"
+  end
+  
+  def baz a
+    "#{a} should respond to :bar"
+  end
+end

data/spec/safe-me/safe-me_spec.rb

@@ -0,0 +1,39 @@
+require 'spec/classes/foo'
+require 'safe-me'
+
+SafeMe.init
+
+describe SafeMe do
+  describe "a class with a safe-me description file" do
+    describe "a method with quacks_like arguments" do
+      it "should only allow arguments, that has the same methods as the specified types" do
+        lambda{Foo.new.a_method 3, 4}.should_not raise_error(ArgumentError)
+        lambda{Foo.new.a_method "3", 4}.should raise_error(ArgumentError, "for argument 1 expected type QuacksLike(Integer)")
+      end
+    end
+    
+    describe "a method with a nilable(Type) argument" do
+      it "should allow this type, or nil" do
+        lambda{Foo.new.another_method 3}.should_not raise_error(ArgumentError)
+        lambda{Foo.new.another_method nil}.should_not raise_error(ArgumentError)
+        lambda{Foo.new.another_method "foo"}.should raise_error(ArgumentError, "for argument 1 expected type Integer or nil")
+      end
+    end
+    
+    describe "a method with an argument of a specified type" do
+      it "should only allow arguments of that type" do
+        lambda{Foo.new.give_string "a string"}.should_not raise_error(ArgumentError)
+        lambda{Foo.new.give_string nil}.should raise_error(ArgumentError, "for argument 1 expected type String")
+        lambda{Foo.new.give_string 1}.should raise_error(ArgumentError, "for argument 1 expected type String")
+      end
+    end
+    
+    describe "a method with an argument that should respond to a method" do
+      it "should only allow arguments that respond to this method" do
+        b = Struct.new("Bar", :bar)
+        lambda{Foo.new.baz b.new}.should_not raise_error(ArgumentError)
+        lambda{Foo.new.baz 1}.should raise_error(ArgumentError, "for argument 1 expected type RespondsTo(bar)")
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: safe-me
+version: !ruby/object:Gem::Version 
+  hash: 59
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- Dario Rexin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-22 00:00:00 +02: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: Add typechecking whenever you need it, without messing up your class files.
+email: dario.rexin@r3-tech.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- Rakefile
+- lib/extensions/array.rb
+- lib/extensions/class.rb
+- lib/extensions/hash.rb
+- lib/extensions/module.rb
+- lib/safe-me/duck_type.rb
+- lib/safe-me/nilable_type.rb
+- lib/safe-me/rails.rb
+- lib/safe-me/responds_to.rb
+- lib/safe-me/safe_loader.rb
+- lib/safe-me/type_safer.rb
+- lib/safe-me/var_args.rb
+- lib/safe-me/version.rb
+- lib/safe-me.rb
+- spec/classes/Foo.rb
+- spec/safe-me/safe-me_spec.rb
+- safe/Foo_safe.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/drexin/safe-me
+licenses: []
+
+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.3.7
+signing_key: 
+specification_version: 3
+summary: "#{s.name}-#{s.version}"
+test_files: []
+