core 0.0.6

data/README.rdoc

@@ -0,0 +1,11 @@
+= Core
+
+Basic helpers used by other kinda projects.
+
+== Installation
+
+  $ sudo gem install core --source http://gemcutter.org
+
+== Usage
+
+Still very alpha, documentation will come later.

data/Rakefile

@@ -0,0 +1,20 @@
+require "rake/testtask"
+
+begin
+  require "hanna/rdoctask"
+rescue LoadError
+  require "rake/rdoctask"
+end
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.test_files = Dir["test/*_test.rb"]
+end
+
+Rake::RDocTask.new do |t|
+  t.title = "Core Documentation"
+  t.main = "README.rdoc"
+  t.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  t.rdoc_dir = "doc"
+end

data/lib/core.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'core', 'module')
+require File.join(File.dirname(__FILE__), 'core', 'object')
+ruby_files = Dir.glob(File.join(File.dirname(__FILE__), 'core', '*.rb'))
+ruby_files.each { |file| require file }
+
+module Kinda #:nodoc:
+  # Basic helpers used by other kinda projects
+  module Core
+    include Accessor
+    include Forwardable
+  end
+end

data/lib/core/accessor.rb

@@ -0,0 +1,114 @@
+module Kinda #:nodoc:
+  module Core #:nodoc:
+    # Improves the Ruby buit-in accessor methods
+    module Accessor
+      ClassMethods = inheritable_extend do
+        def __attr_reader__(*attributes, with_filter, &block)
+          attributes.each do |attribute|
+            if attribute.is_a?(Hash)
+              attribute, source = attribute.first
+            else
+              source = "@#{attribute}"
+            end
+            proc = if with_filter || !block
+              Proc.new do |*args|
+                return send("#{attribute}=", *args) unless args.empty?
+                value = if source[0] == '@'
+                   instance_variable_get(source)
+                else
+                  [*source].inject(self) do |object, symbol|
+                    object.send(symbol)
+                  end
+                end
+                block ? instance_exec(value, &block) : value
+              end
+            else
+              block
+            end
+            send(:define_method, attribute, &proc)
+          end
+        end
+        
+        private :__attr_reader__
+
+        # attr_reader(:name, :age, :size)
+        # attr_reader(:name => :@name) is the default behaviour but you can use:
+        # attr_reader (:name => @the_name) to use a different instance variable
+        # attr_reader(:name => :first_name) or even an another attribute.
+        # More interesting, you can delegate to another object:
+        # attr_reader(:name => [:father, :name])
+        # attr_reader(:name => [:mother, :husband, :name])
+        def attr_reader(*attributes, &block)
+          __attr_reader__(*attributes, false, &block)
+        end
+
+        def attr_reader_with_filter(*attributes, &block)
+          __attr_reader__(*attributes, true, &block)
+        end
+
+        def __attr_writer__(*attributes, with_filter, &block)
+          attributes.each do |attribute|
+            if attribute.is_a?(Hash)
+              attribute, target = attribute.first
+            else
+              target = "@#{attribute}"
+            end
+            proc = if with_filter || !block
+              Proc.new do |value|
+                value = instance_exec(value, &block) if block
+                if target[0] == '@'
+                  instance_variable_set(target, value)
+                else
+                  [*target][0..-2].inject(self) do |object, symbol|
+                    object.send(symbol)
+                  end.send("#{[*target].last}=", value)
+                end
+              end
+            else
+              block
+            end
+            send(:define_method, "#{attribute}=", &proc)
+          end
+        end
+        
+        private :__attr_writer__
+
+        def attr_writer(*attributes, &block)
+          __attr_writer__(*attributes, false, &block)
+        end
+
+        def attr_writer_with_filter(*attributes, &block)
+          __attr_writer__(*attributes, true, &block)
+        end
+
+        def attr_accessor(*attributes, &block)
+          attr_reader(*attributes, &block)
+          attr_writer(*attributes, &block)
+        end
+
+        def attr_accessor_with_filter(*attributes, &block)
+          attr_reader_with_filter(*attributes, &block)
+          attr_writer_with_filter(*attributes, &block)
+        end
+    
+        def attr(attribute, writable=false)
+          attr_reader(attribute)
+          attr_writer(attribute) if writable
+        end
+
+        def attr_reader_with_default(attribute, default_value)
+          attr_reader_with_filter(attribute) do |value|
+            value.nil? ? default_value : value
+          end
+        end
+
+        def attr_accessor_with_default(attribute, default_value)
+          attr_reader_with_default(attribute, default_value)
+          attr_writer(attribute)
+        end
+      end
+
+      delegate_to_class ClassMethods.public_instance_methods
+    end
+  end
+end

data/lib/core/forwardable.rb

@@ -0,0 +1,85 @@
+require 'forwardable'
+
+module Kinda
+  module Core
+    module Forwardable
+      ClassMethods = inheritable_extend do
+        include ::Forwardable
+
+        # Add a nice way to specify a different method for the accessor:
+        # delegate :remove => [:book, :delete]
+        # delegate [:add, :remove] => [:book, :<<, :delete]
+        def instance_delegate(hash)
+          hash.each do |delegate_methods, accessor|
+            accessor_methods = [*accessor]
+            accessor_object = accessor_methods.shift
+            [*delegate_methods].each do |delegate_method|
+              accessor_method = accessor_methods.shift || delegate_method
+              def_instance_delegator(accessor_object, accessor_method, delegate_method)
+            end
+          end
+        end
+        
+        alias_method :delegate, :instance_delegate
+
+        # Create both reader and writer delegate
+        # Same usage than the simple "delegate" method except the following form
+        # in case the getter and setter symbols are different:
+        # delegate_attr :title => [:book, [:read_title, :write_title]]
+        def delegate_attr_accessor(hash, kind=(:accessor), with_filter=false, &block)
+          hash.each do |delegate_methods, accessor|
+            accessor_methods = [*accessor]
+            accessor_object = accessor_methods.shift
+            [*delegate_methods].each do |delegate_method|
+              accessor_method = accessor_methods.shift || delegate_method
+              accessor_getter, accessor_setter = case kind
+              when :accessor
+                getter, setter = [*accessor_method]
+                setter ||= getter
+                [getter, setter]
+              when :reader
+                [accessor_method, nil]
+              when :writer
+                [nil, accessor_method]
+              end
+              if accessor_getter
+                __attr_reader__({ delegate_method => [accessor_object, accessor_getter] },
+                  with_filter, &block)
+              end
+              if accessor_setter
+                __attr_writer__({ delegate_method => [accessor_object, accessor_setter] },
+                  with_filter, &block)
+              end
+            end
+          end
+        end
+      
+        alias_method :delegate_attr, :delegate_attr_accessor
+
+        def delegate_attr_accessor_with_filter(hash, &block)
+          delegate_attr_accessor(hash, :accessor, true, &block)
+        end
+
+        alias_method :delegate_attr_with_filter, :delegate_attr_accessor_with_filter
+
+        def delegate_attr_reader(hash, &block)
+          delegate_attr_accessor(hash, :reader, false, &block)
+        end
+
+        def delegate_attr_reader_with_filter(hash, &block)
+          delegate_attr_accessor(hash, :reader, true, &block)
+        end
+
+        def delegate_attr_writer(hash, &block)
+          delegate_attr_accessor(hash, :writer, false, &block)
+        end
+
+        def delegate_attr_writer_with_filter(hash, &block)
+          delegate_attr_accessor(hash, :writer, true, &block)
+        end
+      end
+
+      delegate_to_class ClassMethods.public_instance_methods
+    end
+  end
+end

data/lib/core/functor.rb

@@ -0,0 +1,19 @@
+module Kinda
+  module Core
+    # Thomas Sawyer's Functor Class slightly modified for Ruby 1.9
+    # http://facets.rubyforge.org/apidoc/api/core/classes/Functor.html
+    class Functor < BasicObject
+      def initialize(&proc)
+        @proc = proc
+      end
+
+      def to_proc
+        @proc
+      end
+
+      def method_missing(method_name, *args, &block)
+        @proc.call(method_name, *args, &block)
+      end
+    end
+  end
+end

data/lib/core/hash.rb

@@ -0,0 +1,13 @@
+module Kinda
+  module Core
+    module HashExtension
+    	def delete_value(value)
+    	  delete_if { |k, v| v == value }
+    	end
+    end
+  end
+end
+
+class Hash #:nodoc:
+  include Kinda::Core::HashExtension
+end

data/lib/core/inspect.rb

@@ -0,0 +1,20 @@
+module Kinda
+  module Core
+    def inspect(*args)
+      if %w[Bignum Class Complex Date DateTime FalseClass Fixnum Float
+          Integer NilClass Numeric Range Rational Regexp String Symbol
+          Time TrueClass].include?(self.class.name)
+        super()
+      else
+        result = '#<'
+        result += "#{self.class}:#{object_hexid}"
+        items = args.map do |arg|
+          "#{arg}=#{send(arg).inspect}" if respond_to?(arg)
+        end.compact
+        result += ' ' + items.join(', ') if !items.empty?
+        result += '>'
+        result
+      end
+    end
+  end
+end

data/lib/core/module.rb

@@ -0,0 +1,93 @@
+module Kinda
+  module Core
+    module ModuleExtension
+      def self.included(klass)
+        klass.alias_method_chain :append_features, :inheritable_extensions
+      end
+
+      def alias_method_chain(target, feature)
+        # Strip out punctuation on predicates or bang methods since
+        # e.g. target?_without_feature is not a valid method name.
+        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+        yield(aliased_target, punctuation) if block_given?
+
+        with_method, without_method =
+          "#{aliased_target}_with_#{feature}#{punctuation}",
+          "#{aliased_target}_without_#{feature}#{punctuation}"
+
+        alias_method without_method, target
+        alias_method target, with_method
+
+        case
+          when public_method_defined?(without_method)
+            public target
+          when protected_method_defined?(without_method)
+            protected target
+          when private_method_defined?(without_method)
+            private target
+        end
+      end
+
+      def container
+        space = name[0...(name.rindex( '::' ) || 0)]
+        space.empty? ? Object : eval(space)
+      end
+
+      def extensions
+        singleton_class.ancestors.take_while { |mod| !mod.is_a?(Class) }
+      end
+
+      def inheritable_extend(*mods, &block)
+        if block
+          mod = Module.new
+          mod.extend extensions
+          mod.module_eval(&block)
+          mods << mod
+        end
+        extend *mods
+        (@inheritable_extensions ||= []).unshift(*mods.reverse).uniq!
+        mod
+      end
+
+      def append_features_with_inheritable_extensions(target)
+        append_features_without_inheritable_extensions(target)
+        if @inheritable_extensions
+          target.extend *@inheritable_extensions
+          target.inheritable_extend *@inheritable_extensions.reverse
+        end
+      end
+
+      # delegate_to_class :singleton_method_added => :method_added
+      # delegate_to_class [:attr_reader, :attr_writer]
+      # delegate_to_class ClassMethods.instance_methods
+      def delegate_to_class(*sources)
+        sources, target = sources.first.first if sources.first.is_a?(Hash)
+        [*sources].flatten.each do |source|
+          define_method(source) do |*args, &block|
+            singleton_class_send(target || source, *args, &block)
+          end
+        end
+      end
+
+      def self_and_ancestors
+        result = ancestors
+        result.unshift self unless result.first == self
+        result
+      end
+
+      def ancestors_without_self
+        result = ancestors
+        result.first == self ? result.drop(1) : result
+      end
+      
+      def ancestor
+        ancestors_without_self.first
+      end
+    end
+  end
+end
+
+class Module #:nodoc:
+  include Kinda::Core::ModuleExtension
+end
+

data/lib/core/object.rb

@@ -0,0 +1,64 @@
+module Kinda
+  module Core
+    module ObjectExtension
+      def self.included(klass)
+        klass.alias_method_chain :extend, :flexible_arguments
+      end
+
+      def object_hexid
+        "0x" + ('%.x' % (self.__id__ * 2))
+      end
+
+      def singleton_class
+        class << self; self; end
+      end
+
+      def singleton_class_eval(&block)
+        singleton_class.class_eval(&block)
+      end
+
+      def singleton_class_send(method_name, *args, &block)
+        singleton_class_eval { send(method_name, *args, &block) }
+      end
+
+      def to_class
+        kind_of?(Module) ? self : singleton_class
+      end
+      
+      alias_method :to_module, :to_class
+
+      def extend_with_flexible_arguments(*modules)
+        mods = modules.flatten
+        extend_without_flexible_arguments(*mods) unless mods.empty?
+      end
+
+      def tap
+        return super if block_given?
+        Functor.new { |method, *args| self.send(method, *args); self }
+      end
+
+      def try(method_name, *args, &block)
+        send(method_name, *args, &block) if respond_to?(method_name)
+      end
+
+      def receiver
+        self
+      end
+
+      alias_method :__instance_exec__, :instance_exec
+
+      def parse_arguments(args, *defaults)
+        args = args.dup
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        raise ArgumentError, "Too many arguments (#{args.size} for #{defaults.size})" if
+          args.size > defaults.size
+        defaults.drop(args.size).each { |default| args << default }
+        args << options
+      end
+    end
+  end
+end
+
+class Object #:nodoc:
+  include Kinda::Core::ObjectExtension
+end

data/lib/core/this.rb

@@ -0,0 +1,78 @@
+module Kinda
+  module Core
+    module This
+      module ProcExtension
+        def call_with_this(this, *args, &block)
+          binding_self = binding.eval('self')
+          binding_self.push_this(this)
+          call(*args, &block)
+        ensure
+          binding_self.pop_this
+        end
+      end
+
+      ###
+
+      def call_with_this(proc, *args, &block)
+        return unless proc
+        binding_self = proc.binding.eval('self')
+        raise "Object #{binding_self.inspect} doesn't respond to Kinda::Core::This methods " +
+          "(proc=#{proc.inspect})" unless binding_self.respond_to?(:push_this)
+        begin
+          binding_self.push_this(self)
+          proc.call(*args, &block)
+        ensure
+          binding_self.pop_this
+        end
+      end
+
+      def push_this(object)
+        (@these ||= []).push(object)
+      end
+    
+      def pop_this
+        @these.pop if @these
+      end
+    
+      def this
+        (@these && @these.last) || self
+      end
+
+      def this_eval(&block)
+        this.instance_eval(&block)
+      end
+
+      attr_reader :contextual_methods
+
+      def contextual_method(*methods)
+        methods.each do |method|
+          (@contextual_methods ||= []) << method.to_sym
+        end
+      end
+      
+      def contextual_method?(method)
+        to_class.self_and_ancestors.each do |ancestor|
+          return true if ancestor.contextual_methods &&
+            ancestor.contextual_methods.include?(method.to_sym)
+        end
+        false
+      end
+      
+      def method_missing(method_name, *args, &block)
+        if this != self && this.contextual_method?(method_name)
+          this.send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+class Object #:nodoc:
+  include Kinda::Core::This
+end
+
+class Proc #:nodoc:
+  include Kinda::Core::This::ProcExtension
+end

data/lib/kinda-core.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'core')

data/test/__all__.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby19
+# encoding: utf-8
+
+ruby_files = Dir.glob(File.join(File.dirname(__FILE__), '*_test.rb'))
+ruby_files.each { |file| require file }

data/test/accessor_test.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/ruby19
+# encoding: utf-8
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')).uniq!
+require 'kinda-core'
+
+class AccessorTest < Test::Unit::TestCase
+  def setup
+    @human_class = Class.new do
+      include Kinda::Core
+    end
+    @human = @human_class.new
+  end
+
+  def test_attribute_defined_at_class_level
+    @human_class.class_eval do
+      attr_accessor :name
+    end
+    assert_nil @human.name
+    @human.name = 'Dave'
+    assert_equal 'Dave', @human.name
+    @human.name 'Fred'
+    assert_equal 'Fred', @human.name
+  end
+  
+  def test_attribute_defined_at_instance_level
+    @human.attr_accessor :name
+    assert_nil @human.name
+    @human.name = 'Dave'
+    assert_equal 'Dave', @human.name
+    @human.name 'Fred'
+    assert_equal 'Fred', @human.name
+    @other_human = @human_class.new
+    assert_raise NoMethodError do
+      @other_human.name
+    end
+  end
+
+  def test_attribute_with_block_defined_at_class_level
+    @human_class.class_eval do      
+      attr_reader :name do |capitalize=false|
+        capitalize ? @the_name.capitalize : @the_name
+      end
+      attr_writer :name do |value|
+        @the_name = value
+      end
+    end
+    assert_equal nil, @human.name
+    @human.name = 'Dave'
+    assert_equal 'Dave', @human.name
+    @human.name = 'fred'
+    assert_equal 'Fred', @human.name(true)
+  end
+ 
+  def test_attribute_with_filter_defined_at_class_level
+    @human_class.class_eval do
+      attr_accessor :nickname
+      
+      attr_reader_with_filter :name do |value|
+        value || nickname || 'Mike'
+      end
+      attr_writer_with_filter :name do |value|
+        value.capitalize
+      end
+    end
+    assert_equal 'Mike', @human.name
+    @human.nickname = 'Mikey'
+    assert_equal 'Mikey', @human.name
+    @human.name = 'dave'
+    assert_equal 'Dave', @human.name
+    @human.name 'FRED'
+    assert_equal 'Fred', @human.name
+  end
+    
+  def test_attribute_redirection
+    @human.attr_accessor :name => :@the_name
+    assert_nil @human.name
+    @human.name = 'Dave'
+    assert_equal 'Dave', @human.name
+    assert_equal 'Dave', @human.instance_variable_get(:@the_name)
+    @human.name = 'Fred'
+    assert_equal 'Fred', @human.name
+    @human.attr_accessor :last_name => :name
+    assert_equal 'Fred', @human.last_name
+    @human.last_name = 'Mike'
+    assert_equal 'Mike', @human.last_name
+    assert_equal 'Mike', @human.name
+  end
+  
+  def test_attribute_delegation
+    @child = @human_class.new
+    @father = @human_class.new
+    @child.attr_accessor :father
+    @child.father = @father
+    assert_equal @father, @child.father
+    @father.attr_accessor :name
+    @father.name = 'Dave'
+    @child.attr_accessor :name => [:father, :name]
+    assert_equal 'Dave', @child.name
+    @child.name = 'Fred'
+    assert_equal 'Fred', @child.name
+    assert_equal 'Fred', @father.name
+  end
+    
+  def test_attribute_double_delegation
+    @child = @human_class.new
+    @mother = @human_class.new
+    @husband = @human_class.new
+    @child.attr_accessor :mother
+    @child.mother = @mother
+    @mother.attr_accessor :husband
+    @mother.husband = @husband    
+    assert_equal @husband, @child.mother.husband
+    @husband.attr_accessor :name
+    @husband.name = 'Dave'
+    @child.attr_accessor :name => [:mother, :husband, :name]
+    assert_equal 'Dave', @child.name
+    @child.name = 'Fred'
+    assert_equal 'Fred', @child.name
+    assert_equal 'Fred', @husband.name
+  end
+  
+  def test_attribute_with_default
+    @human.attr_accessor_with_default :name, 'Bart'
+    assert_equal 'Bart', @human.name
+    @human.name = 'Dave'
+    assert_equal 'Dave', @human.name
+  end
+end

data/test/forwardable_test.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/ruby19
+# encoding: utf-8
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')).uniq!
+require 'kinda-core'
+
+class ForwardableTest < Test::Unit::TestCase
+  def setup
+    @human_class = Class.new do
+      include Kinda::Core
+    end
+    @human = @human_class.new
+  end
+
+  def test_delegate_attribute
+    @child = @human_class.new
+    @father = @human_class.new
+    @child.attr_accessor :father
+    @child.father = @father
+    assert_equal @father, @child.father
+    @father.attr_accessor :name
+    @father.name = 'Dave'
+    @child.delegate_attr :name => :father
+    assert_equal 'Dave', @child.name
+    @child.name = 'Fred'
+    assert_equal 'Fred', @child.name
+    assert_equal 'Fred', @father.name
+  end
+
+  def test_delegate_attribute_with_filter
+    @child = @human_class.new
+    @father = @human_class.new
+    @child.attr_accessor :father
+    @child.father = @father
+    assert_equal @father, @child.father
+    @father.attr_accessor :name
+    @father.name = 'Dave'
+    @child.delegate_attr_reader_with_filter :name => :father do |value|
+      value + ' junior'
+    end
+    assert_equal 'Dave junior', @child.name
+    @child.delegate_attr_writer_with_filter :name => :father do |value|
+      value.capitalize
+    end
+    @child.name = 'fred'
+    assert_equal 'Fred junior', @child.name
+    assert_equal 'Fred', @father.name
+  end
+end

data/test/module_test.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/ruby19
+# encoding: utf-8
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')).uniq!
+require 'kinda-core'
+
+class ModuleTest < Test::Unit::TestCase
+  def meth
+    'meth'
+  end
+  
+  def meth_with_upcase
+    meth_without_upcase.upcase
+  end
+  
+  alias_method_chain :meth, :upcase
+  
+  def test_alias_method_chain
+    assert_equal 'METH', meth
+  end
+  
+  $meth2 = []
+  
+  module A
+    module ClassMethods1  
+      def meth1
+        'meth1'
+      end
+    end
+
+    module ClassMethods2
+      def meth2
+        $meth2 << 'ClassMethods2.meth2'
+      end
+    end
+
+    inheritable_extend ClassMethods1, ClassMethods2
+  end
+
+  module B
+    include A
+
+    ClassMethods3 = inheritable_extend do
+      $meth1 = meth1
+
+      def meth3
+        'meth3'
+      end
+    end
+
+    module ClassMethods4
+      def meth2
+        super
+        $meth2 << 'ClassMethods4.meth2'
+      end
+    end
+
+    inheritable_extend ClassMethods4
+  end
+
+  class X
+    include B
+  end
+
+  def test_container
+    assert_equal ModuleTest::A, ModuleTest::A::ClassMethods1.container
+    assert_equal ModuleTest::B, ModuleTest::B::ClassMethods3.container
+  end
+
+  def test_extensions
+    assert_equal [ModuleTest::B::ClassMethods4, ModuleTest::B::ClassMethods3,
+      ModuleTest::A::ClassMethods2, ModuleTest::A::ClassMethods1], X.extensions
+  end
+  
+  def test_inheritable_extend
+    assert_equal 'meth1', $meth1
+    X.meth2
+    assert_equal ["ClassMethods2.meth2", "ClassMethods4.meth2"], $meth2
+    assert_equal 'meth1', X.meth1
+    assert_equal 'meth3', X.meth3
+  end  
+end

data/test/object_test.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby19
+# encoding: utf-8
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')).uniq!
+require 'kinda-core'
+
+class ObjectTest < Test::Unit::TestCase
+  def test_tap
+    assert_equal 'Hello', 'Hello'.tap { |str| assert_equal 'HELLO', str.upcase }
+    assert_equal 'Hello', 'Hello'.tap.upcase
+  end  
+  
+  def test_try
+    assert_equal nil, 'Hello'.try(:undefined)
+    assert_equal 'HELLO', 'Hello'.try(:upcase)
+    assert_equal 'hello', 'Hello'.try(:upcase).try(:downcase)    
+  end
+  
+  def test_parse_arguments
+    assert_equal [1, 2, {}], parse_arguments([], 1, 2)
+    assert_equal [3, 4, {}], parse_arguments([3, 4], 1, 2)
+    assert_raise(ArgumentError) { parse_arguments([3, 4, 5], 1, 2) }
+    assert_equal [1, 2, {:a => 'c', :b => 'd'}], parse_arguments([:a => 'c', :b => 'd'], 1, 2)
+    assert_equal [3, 2, {:a => 'c', :b => 'd'}], parse_arguments([3, :a => 'c', :b => 'd'], 1, 2)
+  end
+end

data/test/this_test.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/ruby19
+# encoding: utf-8
+
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')).uniq!
+require 'kinda-core'
+
+class ThisTest < Test::Unit::TestCase
+  
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: core
+version: !ruby/object:Gem::Version 
+  version: 0.0.6
+platform: ruby
+authors: 
+- Manuel Vila
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-12 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Basic helpers used by other kinda projects
+email: mvila@3base.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Rakefile
+- lib/core.rb
+- lib/kinda-core.rb
+- lib/core/accessor.rb
+- lib/core/forwardable.rb
+- lib/core/functor.rb
+- lib/core/hash.rb
+- lib/core/inspect.rb
+- lib/core/module.rb
+- lib/core/object.rb
+- lib/core/this.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/kinda/core
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.1
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: kinda-core
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Basic helpers used by other kinda projects
+test_files: 
+- test/__all__.rb
+- test/accessor_test.rb
+- test/forwardable_test.rb
+- test/module_test.rb
+- test/object_test.rb
+- test/this_test.rb