rubysierung 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 038d493ea5841626de91eeb6f134e7718fb6acf6
-  data.tar.gz: 1122c17da2a242e1cd6d8596ebe7f921e5b6feeb
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OTFkNDk1ZTEyYmJiZDZiMmFjNTFlMWY0OTE0MmFlY2RlOTA5YjY2YQ==
+  data.tar.gz: !binary |-
+    N2ZhODk2ZjA5MjM4NDVhMTJiNGZhODAxZDlhZjFmNGNiNTVlMjc0ZQ==
 SHA512:
-  metadata.gz: 36b229c7d8aff827db09a889c841d125b97ffaa4566170cd1815502c9db22a8eee24abf8d9f30afa49888cd6bd9cca9d1ab9b0b88c66ab796ed976727c2c7eb2
-  data.tar.gz: 83169296e36c106e58ea7bdb9f04828241db5baeb1686cafa6f7a3877fbdc09f90047766575970fd00ee7a53ec82654d46e690324a6b16ae641c01689af16f02
+  metadata.gz: !binary |-
+    MjcyMTMwODA2MmRmNzU0NzBlNzdlZjhmMTVkMDFiMTU2ZDYzOTc1NWFmZjIw
+    ZGNiNmMwNGNmNDhmODM5OTQ3ZmQ3ZTAwMWIzMmVmNDFjNDM0MGVlNDE2N2Yx
+    MDg3NzgxNzFkODljMmNhNzc2NzQ3NTYyMGEzZjI3NTA1MjRiOTA=
+  data.tar.gz: !binary |-
+    ZjcxYmMwMzJkMWZmZTdhMTdkMWU5YjM4NjAwYTM0OTkyNTkxYTAyMzU4NmI2
+    NzNhOTU1NGVhNTE1ZWJiYzAwZWU2ZTkxNGVmODFlNzBmMTYwODY3YTlkYTcz
+    YzFkNTIwOWQyMjVhZjNkMzA3MjEyODAzYWQxM2RhMzhkZjEwZGE=

data/.hound.yml

@@ -0,0 +1,3 @@
+ruby:
+  enabled: true
+  config_file: .rubocop.yml

data/.travis.yml

@@ -1,3 +1,12 @@
 language: ruby
 rvm:
-    - 2.1.0
+- 2.1.0
+deploy:
+  provider: rubygems
+  api_key:
+    secure: QA2OqytUOFV+W0dcIhULAS6bEZTMRfwrWHFmi1T4Ce3MtZ2o4f2kYsE+9wbFmfKqI35NljsUZYzunbAADGAXuGiir0pzFh5XzCJX/SPCUeNj79UwadByMmfI+dHzRTQdnPeGDsxBSg+N35yPCNenJlAgfX7Ed5YXJ4bAbWjPsds=
+  gem: rubysierung
+  on:
+    tags: true
+    all_branches: true
+    repo: doodzik/rubysierung

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# 0.0.3
+
+- ADD: support of default values
+- ADD: CallBaecker doesn't have to be included manually
+- ADD: @__add_type 3rd argument is now optional and is set to the 2nd type
+- FIX: strict custom_type
+- REFACTOR: Tests seperated into different files
+- REFACTOR: Source splitted into multiple types

data/README.md

@@ -2,17 +2,19 @@
 
 [![Build Status](https://travis-ci.org/doodzik/rubysierung.svg?branch=master)](https://travis-ci.org/doodzik/rubysierung)
 
-Rubysierung is the type system Ruby deserves
+[![doodzik/rubysierung API Documentation](https://www.omniref.com/github/doodzik/rubysierung.png)](https://www.omniref.com/github/doodzik/rubysierung/HEAD)
+
+Rubysierung is an implementation of Soft Typing in Ruby
+
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-# ruby 2.1.0
-
+# ruby >= 2.1.0
+# You can only use Rubysierung in a file context, see issue #5 and #7.
 gem 'rubysierung'
-gem 'CallBaecker', '~> 0.0.3'
 ```
 
 And then execute:
@@ -25,25 +27,28 @@ Or install it yourself as:
 
 ## Usage
 
-## Have a look at all available types in ./lib/rubysierung/types
+## Have a look at all available [Types] (https://github.com/doodzik/rubysierung/blob/master/lib/rubysierung/types.rb#L3-L19)
 
 ```ruby
-require 'CallBaecker'
 require 'rubysierung'
 
-# define a custom type
-class CustomType
-end
+# define a custom types
+class Strict::CustomTyp;end
+class CustomTyp;end
+
+class Strict::CustomTypX;end
+class CustomTypX;end
 
 class Example
   extend Rubysierung
-  include CallBaecker # include Callbaecker after Rubysierung
 
   # if the type doesnt match Rubisierung will raise an Error messages
 
   # add custom Types
-  # [TypeClass, StandartDuckTypeAsSymbol, StrictDuckTypeAsSymbol]# TODO change to proper name
-  @__add_type[CustomTyp, :to_s, :to_str]
+  # if you don't specify a Strict Type the standard type is being set for it
+  # [TypeClass, StandardConversionMethodAsSymbol, StrictConversionMethodSymbol]
+  @__add_type[CustomType, :to_s, :to_str]
+  @__add_type[CustomTypeX, :to_s]
 
   # define foo to respond to :to_s and bar to :to_i
   def one(foo: String, bar: Integer)
@@ -51,23 +56,28 @@ class Example
   end
 
   # you can still define empty/default parameters
-  def self.three(foo: , bar: 'hallo World')
+  def self.two(foo:, bar: 'hallo World')
     [foo, bar]
   end
 
   # use a custom type
-  def self.four(foo: ,bar: CustomType)
+  def self.three(foo:, bar: CustomType)
     [foo, bar]
   end
 
   # define foo to respond to :to_str (strict type)
-  def self.five(foo: Strict::String, bar: Integer)
+  def self.four(foo: Strict::String, bar: Integer)
+    [foo, bar]
+  end
+
+  # with default parameters
+  def self.five(foo: String||'I am a default :)', bar: Integer||42)
     [foo, bar]
   end
 end
 ```
 
-## what would it look like normally
+## what it would look like normally
 ```ruby
 def one(foo:, bar:)
   sFoo = foo.to_s
@@ -76,6 +86,10 @@ def one(foo:, bar:)
 end
 ```
 
+## Other Typing implementations
+(contracts.ruby)[https://github.com/egonSchiele/contracts.ruby]
+(typo)[https://github.com/hannestyden/typo/blob/master/typo.rb]
+
 ## Contributing
 
 1. Fork it ( https://github.com/doodzik/rubysierung/fork )

data/Rakefile

@@ -1,10 +1,12 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rake/testtask'
+require 'rubocop/rake_task'
 
 Rake::TestTask.new do |t|
-    t.libs << 'test'
+  t.libs << 'test'
 end
 
-desc "Run tests"
-task :default => :test
+RuboCop::RakeTask.new
 
+desc 'Run tests and rubocop'
+task default: [:test]

data/lib/ast/ast.rb

@@ -0,0 +1,32 @@
+class AST < Struct.new(:to_parse)
+  # @return [Hash<String, String>] parameter of a method
+  def params
+    get_param_hash to_parse
+  end
+
+  # just so it makes sense in contest of the ast
+  # @return [self] make it chainable
+  def method
+    self
+  end
+
+  private
+
+  # @param declaration_string [String] the string which is being evaluated
+  # @return [Hash<String, String>] parameter of a method
+  def get_param_hash(declaration_string)
+    Hash[
+      *declaration_string.scan(regex_keyword_param).flatten
+    ].reject { |_, v| v =~ regex_isnt_constant }
+  end
+
+  # @return [Regex] which returns keywords and value from ruby string
+  def regex_keyword_param
+    /([a-z][a-zA-Z]+):\s*([^,\n)]+)/
+  end
+
+  # @return [Regex] which checks if the String isn't a Constant
+  def regex_isnt_constant
+    /^[^A-Z]/
+  end
+end

data/lib/rubysierung/ast.rb

@@ -0,0 +1,31 @@
+require 'ast/ast'
+
+module Rubysierung
+  class AST < AST
+    # Calls super and uses it result as a arg for default_param
+    # @return [Array<Hash<>, Hash<Symbol, String>>] returns the same as default_param
+    def params
+      default_param super
+    end
+
+    private
+
+    # @return [Regex] splits default param and type
+    def regex_default_arg
+      /([A-Z]\w*?)\s*\|\|\s*(.+)/
+    end
+
+    # seperates a param from default argument and stores the defaults inside a hash
+    # @param hash [Hash<String, String>] {"foo"=>"String||'bar'", "bar"=>"String||'foo'"}
+    # @return [Array<Hash<String, String>, Hash<Symbol, String>>] params, defaults for params
+    def default_param(hash)
+      defaults = {}
+      hash.map do |k, v|
+        const, default = v.scan(regex_default_arg).flatten
+        next unless const && default
+        hash[k], defaults[k.to_sym] = [const, default]
+      end
+      [hash, defaults]
+    end
+  end
+end

data/lib/rubysierung/core.rb

@@ -0,0 +1,85 @@
+require 'rubysierung/error'
+
+module Rubysierung
+  module Core
+    # sets defaults as @__defaults
+    # @param ast [AST] an instance of modefied ruby ast class
+    # @todo refactor into adapter
+    # @return [Hash<Symbol, Constant>]
+    def default_hash(ast)
+      param_hash, defaults = ast.method.params
+      @__defaults = @__defaults.merge(defaults)
+      convert_value_to_constant param_hash
+    end
+
+    # applies conversion methods on args and returns args(for CallBaecker)
+    # @param klass_hash [Hash<Symbol, Constant>] holds types for Arguments
+    # @param value_hash [Hash<Symbol, Constant>] holds values for Arguments
+    # @return [Hash<Symbol, Constant>] same as value_hash only that on its
+    #   values the type was applied and merged with the other values
+    def call(klass_hash:, value_hash:)
+      return value_hash if klass_hash.empty?
+      return_hash = each_param(klass_hash, value_hash) do |key|
+        @__error_data[:var_sym] = key
+      end
+      value_hash.merge return_hash
+    end
+
+    private
+
+    # @param klass_hash [Hash<Symbol, Constant>] holds types for Arguments
+    # @param value_hash [Hash<Symbol, Constant>] holds values for Arguments
+    # @yield [Symbol] param name
+    # @todo don't use eval -> String.new('default') something like this
+    # @todo refactor: i can't point my finger on it, but it feels bad
+    # @return [Hash] same as value_hash only that on its
+    #   values the type was applied
+    def each_param(klass_hash, value_hash)
+      return_hash = {}
+      klass_hash.keys.map do |key|
+        yield(key) if block_given?
+        value = value_hash[key] ? value_hash[key] : eval(@__defaults[key])
+        return_hash[key] = convert(klass: klass_hash[key], value: value)
+      end
+      return_hash
+    end
+
+    # @param klass [Hash<>]
+    # @option value [Hash<>]
+    # @raise [Rubysierung::Error:Standard|Rubysierung::Error::Strict]
+    # @return [self]
+    def convert(klass:, value: nil)
+      strict, klass = get_kind(klass: klass)
+      type = @__types.reject { |t| klass != t[0] }.flatten
+      klass == type[0] ? value.send(type[1 + strict]) : value
+    rescue NoMethodError
+      err = @__error_data.merge(klass: klass, type: type[1 + strict],
+                          value: value, value_class: value.class)
+      raise Rubysierung::Error.new(err).raise_child strict
+    end
+
+    # @param klass [String] takes the type of a klass
+    # @return [Array<Int, Constant>] if klass is Strict it returns 1 else 0 as
+    #     the int. So that we can look up the conversion method in @__types
+    #     and a klass without strict prefix
+    def get_kind(klass:)
+      if klass.respond_to? :name
+        splitted, splitted1 = klass.name.split('::')
+        splitted == 'Strict' ? [1, Kernel.const_get(splitted1)] : [0, klass]
+      else
+        [0, klass]
+      end
+    end
+
+    # @note this could be the point where we could use Symbols instead
+    #    of Constants.
+    # @param hash [Hash<String, String>] takes a string string hash
+    # @todo refactor into adapter
+    # @return [Hash<Symbol, Constant>] returns a symbol Constant hash
+    def convert_value_to_constant(hash)
+      Hash[hash.map do |k, v|
+        [k.to_sym, Kernel.const_get(v)]
+      end]
+    end
+  end
+end

data/lib/rubysierung/error.rb

@@ -1,4 +1,55 @@
-module Rubysierung::Error
-  class Standard < StandardError; end
-  class Strict   < StandardError; end
+module Rubysierung
+  class Error < StandardError
+    # @param error_data [Hash<..>] look at message what is needed
+    # @return [void]
+    def initialize(error_data)
+      @error_data = error_data
+    end
+
+    # @param strict [Int] 0 or 1, 1 if it strict
+    # @return [Rubysierung::Error::Standard|Rubysierung::Error::Strict] instance of one of the two classes
+    def raise_child(strict)
+      if strict == 0
+        Rubysierung::Error::Standard.new(@error_data)
+      else
+        Rubysierung::Error::Strict.new(@error_data)
+      end
+    end
+
+    # @todo refactor into idependend methods and assemble them inside message
+    # @return [String] error message
+    def message
+      "Class:#{@error_data[:klass]}, Conversion Method:#{@error_data[:type]}, Method:#{@error_data[:method_object]}:#{@error_data[:method_file]} #{@error_data[:method_name]}:#{@error_data[:method_line]} -- called on #{@error_data[:caller]} with #{@error_data[:var_sym]}:#{@error_data[:value]} of #{@error_data[:value_class]} doesn't respond to #{@error_data[:type]}"
+    end
+
+    # sets @__error_data on provided obj pointer
+    # @param _self [self]
+    # @param name [Symbol]
+    # @param method_object [?]
+    # @param file [String]
+    # @param line [Int]
+    # @return [void]
+    def self.set_data(_self:, name:, method_object:, file:, line:)
+      err_data = _self.instance_variable_get :@__error_data
+      err_data[:method_object] = method_object
+      err_data[:method_file]   = file
+      err_data[:method_name]   = name
+      err_data[:method_line]   = line
+      _self.instance_variable_set :@__error_data, err_data
+    end
+  end
+
+  class Error::Standard < Error
+    # @return [String] Rubysierung::Error prefixed with self namespace
+    def message
+      "#{to_s}: #{super}"
+    end
+  end
+
+  class Error::Strict < Error
+    # @return [String] Rubysierung::Error prefixed with self namespace
+    def message
+      "#{to_s}: #{super}"
+    end
+  end
 end

data/lib/rubysierung/types.rb

@@ -9,11 +9,11 @@ module Rubysierung::Types
     [Float,    :to_f,    :to_f],
     [Hash,     :to_h,    :to_hash],
     [Rational, :to_r,    :to_r],
-    #[Enum,    :to_enum, :to_enum],
+    # [Enum,    :to_enum, :to_enum],
     [IO,       :to_io,   :to_io],
     [Proc,     :to_proc, :to_proc],
-    #[Path,    :to_path, :to_path],
-    #[JSON,    :to_json, :to_json],
+    # [Path,    :to_path, :to_path],
+    # [JSON,    :to_json, :to_json],
     [Symbol,   :to_sym,  :to_sym],
     [Thread,   :join,    :join]
   ]
@@ -23,13 +23,13 @@ module Rubysierung::Types
   end
 end
 
-# Make Strict types accessible in Global namespace 
+# Make Strict types accessible in Global namespace
 module Strict
 end
 
-strictEval = ""
+strict_eval = ''
 
-Rubysierung::Types.types.map { |types| strictEval += "class #{types[0]} ;end;" }
-Strict.module_eval strictEval
+Rubysierung::Types.types.map { |typ| strict_eval += "class #{typ[0]} ;end;" }
+Strict.module_eval strict_eval
 
-strictEval = nil
+strict_eval = nil

data/lib/rubysierung/version.rb

@@ -1,3 +1,3 @@
 module Rubysierung
-  VERSION = "0.0.2"
+  VERSION = '0.0.3'
 end

data/lib/rubysierung.rb

@@ -1,92 +1,91 @@
-require "rubysierung/version"
+require 'rubysierung/version'
 require 'rubysierung/types'
-require 'rubysierung/error'
+require 'rubysierung/core'
+require 'rubysierung/ast'
+require 'CallBaecker'
 
+# This is currently works as an Adapter for Rubysierung
+# @todo refactor into its own adapter module
 module Rubysierung
-  def self.extended(base)
-    base.instance_variable_set :@__types_show, -> () do
-      puts @__types
-    end
-
-    base.instance_variable_set :@__add_type, -> (klass, standard, strict) do
-      @__types << [klass, standard, strict]
-    end
-
-    base.instance_variable_set :@__before_hook, -> (i,ii, callee) do
-      @__error_data[:caller] = callee
-      Rubysierung.convert_multiple(klass_hash: i, value_hash: ii)
-    end
-
-    base.instance_variable_set :@__setup_instance_method, -> (_self, name) do
-      file, line = _self.instance_method(name.to_sym).source_location
-      set_error_data(_self: self, name: name, method_object: _self.name, file: file, line: line - 1)
-      get_default_hash_from_fileline(file: file, line: line-1)
-    end
-
-    base.instance_variable_set :@__setup_class_method, -> (_self, name) do
-      file, line = _self.method(name.to_sym).source_location
-      set_error_data(_self: self, name: name, method_object: _self.name, file: file, line: line - 1)
-      get_default_hash_from_fileline(file: file, line: line-1)
-    end
+  class << self
+    include Rubysierung::Core
   end
 
   @__types = Rubysierung::Types.types
+  # error data of the current method
   @__error_data = {}
-  class << self
-    def get_default_hash_from_fileline(file:, line:)
-      params_matcher =  /([a-z][a-zA-Z]+):\s*([^,\n)]+)/
-      def_line = IO.readlines(file)[line]
-      flatten_hash = Hash[*def_line.scan(params_matcher).flatten]
-      myhash = flatten_hash.reject { |k,v| v =~ /^[^A-Z]/}
-      Hash[myhash.map{|(k,v)| [k.to_sym, Kernel.const_get(v)]}]
-    end
+  # default parameters of the current method
+  @__defaults = {}
+  @__method_data = {}
+
+  # @todo access __type through method and make it return the types not print
+  # @return [void] puts all current types
+  @__types_show = -> () do
+    puts @__types
+  end
 
-    def convert_multiple(klass_hash:, value_hash:)
-      return_hash = {}
-      return value_hash if klass_hash.empty?
-      klass_hash.keys.map do |key|
-        @__error_data[:var_sym] = key
-        return_hash[key] = convert(klass: klass_hash[key], value: value_hash[key])
-      end
-      value_hash.merge return_hash
+  # @param base [self] pointer to the class on which it is extended
+  # @todo get rid of this method in order to understand the source better
+  # @todo refactor into adapter
+  # @return [void]
+  def self.extended(base)
+    # @__before_hook is called by CallBaecker inside the defined method
+    #    then Rubysierung is called with the klass_hash and value_hash
+    # @note This lambda is called before anything happens in a method
+    # @note This is the starting point of Rubysierung.
+    # @param klass_hash [Hash<Symbol, Constant>] holds types for Arguments
+    # @param value_hash [Hash<Symbol, Constant>] holds values for Arguments
+    # @param callee [String] first element of the current execution stack
+    # @param _self [self]
+    # @param name [String] name of method
+    # @see CallBaecker
+    # @return [self]
+    base.instance_variable_set :@__before_hook, -> (klass_hash, value_hash, callee, _self, name) do
+      @__error_data[:caller] = callee
+      Error.set_data @__method_data[name]
+      Rubysierung.call(klass_hash: klass_hash, value_hash: value_hash)
     end
 
-    def convert(klass:, value:)
-      strict = 0
-      @__types.map do |type|
-        strict, klass = get_kind(klass: klass)
-        begin
-          if klass == type[0]
-            return value.send(type[1+strict])
-          end
-        rescue NoMethodError
-          # return argument, param, duck_type, calle/receiver -> file, line
-          if strict == 0
-            raise Rubysierung::Error::Standart, "Rubysierung::Error::Standart: Class:#{klass}, DuckType:#{type[2]}, Method:#{@__error_data[:method_object]}:#{@__error_data[:method_file]}#{@__error_data[:method_name]}:#{@__error_data[:method_line]} -- called on #{@__error_data[:caller]} with #{@__error_data[:var_sym]}:#{value} of #{value.class} doesn't respond to #{type[2]}"
-          else
-            raise Rubysierung::Error::Strict, "Rubysierung::Error::Strict: Class:#{klass}, DuckType:#{type[2]}, Method:#{@__error_data[:method_object]}:#{@__error_data[:method_file]}#{@__error_data[:method_name]}:#{@__error_data[:method_line]} -- called on #{@__error_data[:caller]} with #{@__error_data[:var_sym]}:#{value} of #{value.class} doesn't respond to #{type[2]}"
-          end
-        end
-      end
-      value
+    # pushes an custom type onto @__types
+    # @param klass [Constant] the CustomType
+    # @param standard [Symbol] the standard conversion method
+    # @param strict [Symbol] the strict conversion method
+    # @todo access __type through method
+    # @return [self]
+    base.instance_variable_set :@__add_type, -> (klass, standard, strict = standard) do
+      @__types << [klass, standard, strict]
     end
 
-    def get_kind(klass:)
-      if klass.respond_to? :name
-        splitted = klass.name.split('::')
-        splitted[0] == 'Strict' ? [1, Kernel.const_get(splitted[1])] : [0, klass]
-      else
-        [0, klass]
-      end
+    # @note This lambda is called before a method is defined inside method added
+    # @param _self [self] pointer to the implementation object
+    # @param name [Symbol] name of the method
+    # @see CallBaecker
+    # @todo get rid of :@__setup_instance_method/:@__setup_class_method
+    #    and make it one
+    # @return [self]
+    base.instance_variable_set :@__setup_instance_method, -> (_self, name) do
+      file, line = _self.instance_method(name).source_location
+      ruby_str = IO.readlines(file)[line-1]
+      ast = Rubysierung::AST.new(ruby_str)
+      @__method_data[name] = {_self: self, name: name, method_object: _self.name, file: file, line: line}
+      default_hash(ast)
     end
 
-    def set_error_data(_self:, name:, method_object:, file:, line:)
-      err_data = _self.instance_variable_get :@__error_data
-      err_data[:method_object] = method_object
-      err_data[:method_file]   = file
-      err_data[:method_name]   = name
-      err_data[:method_line]   = line
-      _self.instance_variable_set :@__error_data, err_data
+    # @note This lambda is called before a method is defined inside method added
+    # @param _self [self] pointer to the implementation object
+    # @param name [Symbol] name of the method
+    # @todo get rid of :@__setup_instance_method/:@__setup_class_method
+    #    and make it one
+    # @see CallBaecker
+    # @return [self]
+    base.instance_variable_set :@__setup_class_method, -> (_self, name) do
+      file, line = _self.method(name).source_location
+      ruby_str = IO.readlines(file)[line-1]
+      ast = Rubysierung::AST.new(ruby_str)
+      @__method_data[name] = {_self: self, name: name, method_object: _self.name, file: file, line: line}
+      default_hash(ast)
     end
+
+    base.include CallBaecker
   end
 end

data/rubysierung.gemspec

@@ -4,21 +4,24 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rubysierung/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "rubysierung"
+  spec.name          = 'rubysierung'
   spec.version       = Rubysierung::VERSION
-  spec.authors       = ["doodzik"]
-  spec.email         = ["4004blog@gmail.com"]
-  spec.summary       = %q{Rubysierung is the type system Ruby deserves}
-  spec.homepage      = "https://github.com/doodzik/rubysierung"
-  spec.license       = "MIT"
+  spec.authors       = ['doodzik']
+  spec.email         = ['4004blog@gmail.com']
+  spec.summary       = %q(Rubysierung is the type system Ruby deserves)
+  spec.homepage      = 'https://github.com/doodzik/rubysierung'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '~> 2.1'
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "CallBaecker", "> 0.0.3"
-  spec.add_development_dependency "minitest"
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'rubocop'
+
+  spec.add_dependency 'CallBaecker', '0.0.4'
 end

data/test/test_ast.rb

@@ -0,0 +1,39 @@
+require 'minitest/autorun'
+require 'ast/ast'
+
+class AstTest < Minitest::Test
+  def test_params
+    ast = AST.new "def self.example2(foo: Strict::String, bar: Integer, buz: String||'fu')"
+    result = ast.send :params
+    assert_equal({"foo"=>"Strict::String", "bar"=>"Integer", "buz"=>"String||'fu'"}, result)
+  end
+
+  def test_method
+    ast = AST.new ''
+    assert_equal ast, ast.method
+  end
+
+  def test_regex_isnt_constant
+    ast = AST.new ''
+    regex = ast.send :regex_isnt_constant#/^[^A-Z]/
+    assert_equal(nil, regex  =~ 'Foo')
+    assert_equal(0, regex  =~ 'foo')
+  end
+
+  def test_regex_keyword_param
+    ast = AST.new ''
+    regex = ast.send :regex_keyword_param#/([a-z][a-zA-Z]+):\s*([^,\n)]+)/
+    str = "def self.example2(foo: Strict::String, bar: Integer, buz: String||'fu')"
+    assert_equal(str.scan(regex).flatten,
+          ['foo', 'Strict::String', 'bar', 'Integer', 'buz', "String||'fu'"])
+  end
+
+  def test_get_param_hash
+    # @param declaration_string [String] the string which is being evaluated
+    # @return [Hash<String, String>] parameter of a method
+    ast = AST.new ''
+    str = "def self.example2(foo: Strict::String, bar: Integer, buz: String||'fu')"
+    result = ast.send :get_param_hash, str
+    assert_equal({"foo"=>"Strict::String", "bar"=>"Integer", "buz"=>"String||'fu'"}, result)
+  end
+end

data/test/test_core.rb

@@ -0,0 +1,31 @@
+require 'minitest/autorun'
+require 'rubysierung'
+
+class RubysierungCoreTest < Minitest::Test
+  def test_rubisierung_converte_Int_to_string
+    assert_equal('23', Rubysierung.send(:convert, { klass: String, value: 23 }))
+  end
+  def test_rubisierung_converte_string_to_Int
+    assert_equal(23, Rubysierung.send(:convert, { klass: Integer, value: '23' }))
+  end
+
+  def test_rubisierung_converte_pass_nonexisting_klass_then_return_value
+    assert_equal('23', Rubysierung.send(:convert, { klass: 'huhu', value: '23' }))
+  end
+
+  def test_run_type_hash_agains_value_hash
+    assert_equal({ foo: 23, bar: '23' },
+                 Rubysierung.call(value_hash: { foo: '23', bar: 23 },
+                                              klass_hash: { foo: Integer, bar: String }))
+  end
+  def test_run_type_hash_agains_value_hash_without_a_class_on_klass_hash
+    assert_equal({ foo: '23', bar: '23' },
+                 Rubysierung.call(value_hash: { foo: '23', bar: 23 },
+                                              klass_hash: { foo: 14, bar: String }))
+  end
+
+  def test_is_strict
+    assert_equal([0, String], Rubysierung.send(:get_kind, { klass: String }))
+    assert_equal([1, String], Rubysierung.send(:get_kind, { klass: Strict::String }))
+  end
+end

data/test/test_error.rb

@@ -0,0 +1,45 @@
+require 'minitest/autorun'
+require 'rubysierung'
+
+class SetupError
+  attr_reader :__error_data
+  def initialize
+    @__error_data = {}
+  end
+
+  def example
+    Rubysierung::Error.set_data(_self: self, name: 42, method_object: 42, file: 42, line: 42)
+  end
+end
+
+class RubysierungErrorTest < Minitest::Test
+  def test_Error
+    data = {}
+    [:klass, :type, :method_object, :method_file, :method_name, :method_line, :caller, :var_sym, :value, :value_class, :type].map { |sym| data[sym] = '42' }
+    raise Rubysierung::Error.new(data)
+  rescue Rubysierung::Error => e
+    assert_equal("Class:42, Conversion Method:42, Method:42:42 42:42 -- called on 42 with 42:42 of 42 doesn't respond to 42", e.message)
+  end
+
+  def test_Error_Standard
+    data = {}
+    [:klass, :type, :method_object, :method_file, :method_name, :method_line, :caller, :var_sym, :value, :value_class, :type].map { |sym| data[sym] = '42' }
+    raise Rubysierung::Error::Standard.new(data)
+  rescue Rubysierung::Error::Standard => e
+    assert_equal("Rubysierung::Error::Standard: Class:42, Conversion Method:42, Method:42:42 42:42 -- called on 42 with 42:42 of 42 doesn't respond to 42", e.message)
+  end
+
+  def test_Error_Strict
+    data = {}
+    [:klass, :type, :method_object, :method_file, :method_name, :method_line, :caller, :var_sym, :value, :value_class, :type].map { |sym| data[sym] = '42' }
+    fail Rubysierung::Error::Strict.new(data)
+  rescue Rubysierung::Error::Strict => e
+    assert_equal("Rubysierung::Error::Strict: Class:42, Conversion Method:42, Method:42:42 42:42 -- called on 42 with 42:42 of 42 doesn't respond to 42", e.message)
+  end
+
+  def test_set_data
+    s_e = SetupError.new
+    s_e.example
+    assert_equal({ method_object: 42, method_file: 42, method_name: 42, method_line: 42 }, s_e.__error_data)
+  end
+end

data/test/test_rubysierung.rb

@@ -1,15 +1,8 @@
 require 'minitest/autorun'
-require 'CallBaecker'
 require 'rubysierung'
 
-class CustomTyp
-end
-
-class Setup
+class SetupRubysierung
   extend Rubysierung
-  include CallBaecker
-
-  @__add_type[CustomTyp, :to_s, :to_str]
 
   def example1(foo: String, bar: Integer)
     [foo, bar]
@@ -19,93 +12,52 @@ class Setup
     [foo, bar]
   end
 
-  def self.example3(foo: , bar: 'hallo World')
-    [foo, bar]
-  end
-
-  # custom Class
-  def self.example4(foo: ,bar: CustomTyp)
+  def self.example3(foo:, bar: 'hallo World')
     [foo, bar]
   end
 
-  # strict
-  def self.example5(foo: Strict::String, bar: Integer)
+  # Default
+  def self.example4(foo: String||'bar', bar: String||'foo')
     [foo, bar]
   end
 
   # Default
-  # def self.example6(foo: Default.new(String, 'bar'), bar: Default.new(String, 'foo'))
-  #   [foo, bar]
-  # end
+  def self.example_err(foo: Strict::String, bar: String||'foo')
+    [foo, bar, (__LINE__ - 1), caller]
+  end
 end
 
 class RubysierungTest < Minitest::Test
-  def test_rubisierung_converte_Int_to_string
-    assert_equal('23', Rubysierung.convert(klass: String, value: 23))
-  end
-  def test_rubisierung_converte_string_to_Int
-    assert_equal(23, Rubysierung.convert(klass: Integer, value: '23'))
-  end
-
-  def test_rubisierung_converte_pass_nonexisting_klass_then_return_value
-    assert_equal('23', Rubysierung.convert(klass: 'huhu', value: '23'))
-  end
-
-  def test_run_type_hash_agains_value_hash
-    assert_equal({foo: 23, bar:'23'},
-                 Rubysierung.convert_multiple(value_hash: {foo: '23', bar: 23},
-                                              klass_hash: {foo: Integer, bar: String}))
-  end
-  def test_run_type_hash_agains_value_hash_without_a_class_on_klass_hash
-    assert_equal({foo: '23', bar:'23'},
-                 Rubysierung.convert_multiple(value_hash: {foo: '23', bar: 23},
-                                              klass_hash: {foo: 14, bar: String}))
-  end
-
-  def test_is_strict
-    assert_equal([0, String], Rubysierung.get_kind(klass: String))
-    assert_equal([1, String], Rubysierung.get_kind(klass: Strict::String))
+  def test_error_implementation
+    SetupRubysierung.example_err(foo: 4, bar: '3')
+  rescue Rubysierung::Error::Strict => e
+    foo, bar, line, callee = SetupRubysierung.example_err(foo: '4', bar: '3')
+    data = {klass: 'String', type: 'to_str', method_object: 'SetupRubysierung', method_file: __FILE__, method_name: 'example_err', method_line: line, caller: callee[4] , var_sym: 'foo', value: '4', value_class: 'Fixnum'}
+    str = Rubysierung::Error::Strict.new(data).message
+    assert_equal(str, e.message)
   end
 
   def test_example_2_standart
-    foo, bar= Setup.example2(foo: 4, bar: '3')
+    foo, bar = SetupRubysierung.example2(foo: 4, bar: '3')
     assert_equal(3, bar)
     assert_equal('4', foo)
   end
 
   def test_example_1_instance_method
-    foo, bar= Setup.new.example1(foo: 4, bar: '3')
+    foo, bar = SetupRubysierung.new.example1(foo: 4, bar: '3')
     assert_equal(3, bar)
     assert_equal('4', foo)
   end
 
   def test_example_3_default_works
-    foo, bar= Setup.example3(foo: 4)
+    foo, bar = SetupRubysierung.example3(foo: 4)
     assert_equal('hallo World', bar)
     assert_equal(4, foo)
   end
 
-  def test_example_4_custum_type
-    foo, bar = Setup.example4(foo: 4, bar: 3)
-    assert_equal('3', bar)
-    assert_equal(4, foo)
+  def test_example_4_default_value
+    foo, bar = SetupRubysierung.example4(bar: 'buz')
+    assert_equal('buz', bar)
+    assert_equal('bar', foo)
   end
-
-  def test_example_5_strict_type
-    foo, bar = Setup.example5(foo: '4', bar: 2)
-    assert_equal(2, bar)
-    assert_equal('4', foo)
-    begin
-      Setup.example5(foo: 4, bar: 2)
-      assert_equal(false, true)
-    rescue StandardError => e
-      assert_equal(true, true)
-    end
-  end
-
-  # def test_example_6_default_value
-  #   foo, bar = Setup.example5(bar: 'bar')
-  #   assert_equal('bar', bar)
-  #   assert_equal('bar', foo)
-  # end
 end

data/test/test_rubysierung_ast.rb

@@ -0,0 +1,25 @@
+require 'minitest/autorun'
+require 'rubysierung/ast'
+
+class RubysierungAstTest < Minitest::Test
+  def test_params
+    ast = Rubysierung::AST.new "def self.example2(foo: Strict::String, bar: Integer, buz: String||'fu')"
+    param, default = ast.params
+    assert_equal({"foo"=>"Strict::String", "bar"=>"Integer", "buz"=>"String"}, param)
+    assert_equal({:buz=>"'fu'"}, default)
+  end
+
+  def test_regex_default_arg
+    ast = Rubysierung::AST.new ''
+    regex = ast.send :regex_default_arg
+    str = "String||'fu'"
+    assert_equal(str.scan(regex).flatten, ['String', "'fu'"])
+  end
+
+  def test_default_param
+    ast = Rubysierung::AST.new ''
+    param, default = ast.send :default_param, {"foo"=>"String||'bar'", "bar"=>"String||'foo'"}
+    assert_equal({'foo' => 'String', 'bar' => 'String'}, param)
+    assert_equal({foo: "'bar'", bar: "'foo'"}, default)
+  end
+end

data/test/test_types.rb

@@ -0,0 +1,51 @@
+require 'minitest/autorun'
+require 'rubysierung'
+
+class Strict::CustomTyp;end
+class CustomTyp;end
+
+
+class SetupRubysierungTypes
+  extend Rubysierung
+
+  @__add_type[CustomTyp, :to_s, :to_str]
+
+  # custom Class
+  def self.example1(foo:, bar: CustomTyp)
+    [foo, bar]
+  end
+
+  # strict
+  def self.example2(foo: Strict::String, bar: Integer)
+    [foo, bar]
+  end
+
+  # Custom strict
+  def self.example3(foo: Strict::String, bar: Strict::CustomTyp)
+    [foo, bar]
+  end
+end
+
+class RubysierungTypesTest < Minitest::Test
+  def test_example_1_custum_type
+    foo, bar = SetupRubysierungTypes.example1(foo: 4, bar: 3)
+    assert_equal('3', bar)
+    assert_equal(4, foo)
+  end
+
+  def test_example_2_strict_type
+    foo, bar = SetupRubysierungTypes.example2(foo: '4', bar: 2)
+    assert_equal(2, bar)
+    assert_equal('4', foo)
+    SetupRubysierungTypes.example2(foo: 4, bar: 2)
+    assert_equal(false, true)
+  rescue StandardError
+    assert_equal(true, true)
+  end
+
+  def test_example_3_custum_type_strict
+    foo, bar = SetupRubysierungTypes.example3(foo: '4', bar: 'hi')
+    assert_equal('hi', bar)
+    assert_equal('4', foo)
+  end
+end

metadata

@@ -1,71 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: rubysierung
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - doodzik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-16 00:00:00.000000000 Z
+date: 2014-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: CallBaecker
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: CallBaecker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
 description: 
 email:
 - 4004blog@gmail.com
@@ -73,18 +87,29 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .hound.yml
+- .rubocop.yml
+- .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/ast/ast.rb
 - lib/rubysierung.rb
+- lib/rubysierung/ast.rb
+- lib/rubysierung/core.rb
 - lib/rubysierung/error.rb
 - lib/rubysierung/types.rb
 - lib/rubysierung/version.rb
 - rubysierung.gemspec
+- test/test_ast.rb
+- test/test_core.rb
+- test/test_error.rb
 - test/test_rubysierung.rb
+- test/test_rubysierung_ast.rb
+- test/test_types.rb
 homepage: https://github.com/doodzik/rubysierung
 licenses:
 - MIT
@@ -95,20 +120,24 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ~>
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
 summary: Rubysierung is the type system Ruby deserves
 test_files:
+- test/test_ast.rb
+- test/test_core.rb
+- test/test_error.rb
 - test/test_rubysierung.rb
-has_rdoc: 
+- test/test_rubysierung_ast.rb
+- test/test_types.rb