kinda-core 0.0.2

data/README.rdoc

@@ -0,0 +1,14 @@
+Author:: Manuel Vila (mailto:mvila@3base.com)
+License:: Don't know yet
+
+= Core
+
+Basic helpers used by other kinda projects.
+
+== Installation
+
+  $ sudo gem install kinda-core --source http://gems.github.com
+
+== Usage
+
+Still very alpha so documentation will come later.

data/lib/core/accessor.rb

@@ -0,0 +1,110 @@
+module Kinda
+  module Core
+    module Accessor
+      module ClassMethods
+        # 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.
+        # But more interesting, you can delegate to another object:
+        # attr_reader(:name => [:father, :name])
+        # attr_reader(:name => [:mother, :husband, :name])
+        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
+            to_class.send(:define_method, attribute, &proc)
+          end
+        end
+
+        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
+            to_class.send(:define_method, "#{attribute}=", &proc)
+          end
+        end
+
+        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
+
+      include ClassMethods
+      inheritable_extension ClassMethods
+    end
+  end
+end

data/lib/core/forwardable.rb

@@ -0,0 +1,86 @@
+require 'forwardable'
+
+module Kinda
+  module Core
+    module Forwardable
+      module ClassMethods
+        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
+
+      include ClassMethods
+      inheritable_extension ClassMethods
+    end
+  end
+end

data/lib/core/functor.rb

@@ -0,0 +1,19 @@
+# Thomas Sawyer's Functor Class slightly modified for Ruby 1.9
+# http://facets.rubyforge.org/apidoc/api/core/classes/Functor.html
+module Kinda
+  module Core
+    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 Hash
+    	def delete_value(value)
+    	  delete_if { |k, v| v == value }
+    	end
+    end
+  end
+end
+
+class Hash
+  include Kinda::Core::Hash
+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,81 @@
+module Kinda
+  module Core
+    module Module
+      def self.included(klass)
+        klass.alias_method_chain :append_features, :module_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_extension(*mods)
+        (@inheritable_extensions ||= []).unshift(mods.reverse).flatten!.uniq!
+      end
+
+      def append_features_with_module_extensions(target)
+        append_features_without_module_extensions(target)
+        if @inheritable_extensions
+          target.extend *@inheritable_extensions
+          target.inheritable_extension *@inheritable_extensions.reverse
+        end
+      end
+
+      def delegate_to_class(source, target=source)
+        define_method(source) do |*args, &block|
+          singleton_class_eval do
+            send(target, *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
+  include Kinda::Core::Module
+end
+

data/lib/core/object.rb

@@ -0,0 +1,63 @@
+module Kinda
+  module Core
+    module Object
+      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 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(methods, *args, &block)
+        methods = [*methods].dup
+        return self if methods.empty?
+        send(methods.shift, *args, &block).try(methods, *args, &block) if
+          respond_to?(methods.first)
+      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
+  include Kinda::Core::Object
+end

data/lib/core/proc.rb

@@ -0,0 +1,17 @@
+module Kinda
+  module Core
+    module Proc
+      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
+  end
+end
+
+class Proc
+  include Kinda::Core::Proc
+end

data/lib/core/this.rb

@@ -0,0 +1,62 @@
+module Kinda
+  module Core
+    module This
+      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
+  include Kinda::Core::This
+end

data/lib/core.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), 'kinda-core', 'module')
+ruby_files = Dir.glob(File.join(File.dirname(__FILE__), 'kinda-core', '*.rb'))
+ruby_files.each { |file| require file }
+
+module Kinda
+  module Core
+    include Accessor
+    include Forwardable
+  end
+end

data/lib/kinda-core.rb

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

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: kinda-core
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Manuel Vila
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Basic helpers used by other kinda projects
+email: mvila@3base.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/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/proc.rb
+- lib/core/this.rb
+- lib/kinda-core.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: "0"
+  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: 2
+summary: Basic helpers used by other kinda projects
+test_files: []
+