named_arguments 0.0.4

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2007-06-03
+
+* 1 major enhancement
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,10 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/named_arguments.rb
+lib/named_arguments/class_settings_mixin.rb
+lib/named_arguments/hash_extended_tools.rb
+lib/named_arguments/method_extensions.rb
+test/unit/named_arguments_test.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,48 @@
+namedarguments
+    by FIX (your name)
+    FIX (url)
+
+== DESCRIPTION:
+  
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+  
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 FIX
+
+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,17 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/named_arguments.rb'
+
+Hoe.new('named_arguments', NamedArguments::VERSION) do |p|
+  p.rubyforge_name = 'named_arguments'
+  # p.author = 'FIX'
+  # p.email = 'FIX'
+  # p.summary = 'FIX'
+  # p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  # p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/named_arguments.rb

@@ -0,0 +1,258 @@
+require File.dirname(__FILE__) + '/named_arguments/method_extensions'
+require File.dirname(__FILE__) + '/named_arguments/hash_extended_tools'
+require File.dirname(__FILE__) + '/named_arguments/class_settings_mixin'
+
+# Adds the following features to a class:
+# 
+# * Pass a hash to new and matching attributes
+#   will be set.
+# * Set default values for arguments (attribute_defaults)
+# * Require arguments (required_fields)
+# * Require kind_of? tests for arguments (required_kind_of)
+# * Change the type of the object passed in (type_converter)
+# 
+# =Sample
+#
+#  class Snark
+#    include NamedArguments
+#    
+#    attr_accessor :color, :size, :name
+#    
+#    attribute_defaults :color => 'blue', :size => lambda {|s| some_method_call(s)}
+#    required_fields :color, :name
+#    required_respond_to :name => :to_s
+#    required_kind_of? :size => Fixnum
+#    type_converter :size => Fixnum
+#  end
+#  
+# = See also
+# 
+# See ClassMethods for more methods:
+# 
+# * ClassMethods#type_converter
+# * ClassMethods#option_attr
+module NamedArguments
+  VERSION = '0.0.4'
+  
+  def self.included target # :nodoc:
+    target.class_eval do
+      include HashExtendedTools
+      include ClassSettingsMixin
+      extend ClassMethods
+      create_class_settings_method :required_fields
+      create_class_settings_method :required_kind_of
+      create_class_settings_method :required_respond_to
+      create_class_settings_method :attribute_defaults
+    end
+  end
+  
+  # Requires that object.snark.kind_of? String be true
+  # on the call to initialize.
+  # 
+  # Throws a NamedArgumentException if that test fails.
+  # 
+  #  required_kind_of :snark => String, :boojum => Fixnum
+  def required_kind_of
+    # Dummy for rdoc
+  end
+  
+  # Requires that the given arguments be present on the 
+  # call to new.
+  # 
+  #  required_fields [:snark, :boojum]
+  # 
+  # or
+  #   
+  #   required_fields :snark
+  def required_fields
+    # Dummy for rdoc
+  end
+  
+  # Requires that the given objects respond to the
+  # method call.
+  # 
+  #  required_respond_to :snark => 'hunt'
+  #  
+  # Raises a NamedArgumentException on failure.
+  def required_respond_to
+    # Dummy for rdoc
+  end
+  
+  # Set defaults for the given attributes.
+  # 
+  # Values can be:
+  # 
+  # * A class.  The #new method is called with no arguments.
+  # * A Proc.  The proc is called with one argument.
+  # * [].  A new array is created.
+  # * {}.  A new hash is created.
+  # 
+  #  attribute_defaults :snark => lambda {|s| String.new s.to_s}
+  #  attribute_defaults :snark => [], :boojum => ObjectTypeFromSomewhereElse
+  #  attribute_defaults :snark => {}
+  def attribute_defaults
+    # Dummy for rdoc
+  end
+  
+  # Set the attributes for this object.  Normally called
+  # by initialize.
+  
+  def attributes_set(args) # :nodoc:
+    set_default_attributes(args)
+    
+    args_plus_defaults = (attribute_defaults? || {}).merge(args)
+    check_required_field args_plus_defaults
+    check_required_kind
+    check_required_respond_to
+  end
+  
+  def set_default_attributes(args) # :nodoc:
+    defaults = {}
+     (attribute_defaults? || {}).each_pair do |k, v|
+      if Class === v
+        result = v.new
+      elsif Proc === v
+        result = v.call self
+      elsif v.class == Array and v.empty?
+        result = Array.new
+      elsif v.class == Hash and v.empty?
+        result = Hash.new
+      else
+        result = v
+      end
+      defaults[k] = result
+    end
+    args = defaults.merge args
+    args.each_pair do
+      |k, v|
+      m = "#{k}="
+      send m, v if respond_to? m
+    end
+  end
+  
+  # An array of field names.  When an object is created
+  # all of these attributes must be passed.  (They can be
+  # set to nil)
+  # 
+  # Note that this can only be called as a class method.
+  
+  # A hash of :fieldname => klass pairs that specify the
+  # required class of each of the attributes.
+  
+  # Checks to make sure all the required fields
+  # are passed in.  
+  # 
+  # See also: required_fields
+  
+  def check_required_field(fields_set) # :nodoc:
+   (required_fields? || []).each do |f|
+      raise ParameterRequired, "Must set parameter: " + f.to_s unless fields_set.has_key? f.to_sym
+    end
+  end
+  
+  # Checks to make sure all the fields specifed in required_kind_of
+  # have the right kind of objects.
+  # 
+  # See also: 
+  # * #required_kind_of
+  # * #set_default_attributes
+  
+  def check_required_kind # :nodoc:
+   (required_kind_of? || {}).each_pair do |k, v|
+      raise WrongClass.new("Wrong class: #{k.to_s}; should have been #{v.to_s}, object is #{self.send(k).inspect}") unless v === self.send(k)
+    end
+  end
+  
+  def check_required_respond_to # :nodoc:
+   (required_respond_to? || {}).each_pair do |k, v|
+      raise MustRespondTo.new("#{k} must respond to #{v}; the object is #{self.send(k).inspect}") unless self.send(k).respond_to?(v)
+    end
+  end
+  
+  # For every key/value pair in +args+, set the
+  # value of the attribute +key+ to +value+.
+  # 
+  #  class Snark
+  #    include NamedArguments
+  #    attr_accessor :boojum
+  #  end
+  #  
+  #  s = Snark.new :boojum => 7
+  def initialize args = {}
+    if kind_of? ActiveRecord::Base
+      super
+    else
+      super()
+    end
+    attributes_set args
+  end
+  
+  def option_attr_get k  # :nodoc:
+    option_attr_storage[k]
+  end
+  
+  def option_attr_set k, v # :nodoc:
+    option_attr_storage[k] = v
+  end
+  
+  def option_attr_storage # :nodoc:
+    self.options ||= {}
+  end
+  
+  def option_attrs_keys # :nodoc:
+    option_attr_storage.keys
+  end
+  
+  def option_attrs_keys_set # :nodoc:
+    option_attrs_keys.select do |k|
+      option_attr_storage.include? k
+    end
+  end
+  
+  # Class methods (methods of the class
+  # object itself) provided when 
+  # NamedArguments in included.
+  module ClassMethods
+    def option_attr *array_of_names
+      array_of_names.each { |n| 
+        define_method n, lambda {
+          option_attr_get n
+        }
+        define_method "#{n}=", lambda { |v|
+          option_attr_set n, v
+        }
+      }
+    end
+    
+    def type_converter field, new_klass
+      alias_name = ('attribute_setter_for_' + field.to_s).to_sym
+      setter_method_name = (field.to_s + '=').to_sym
+      alias_method alias_name, setter_method_name
+      send :define_method, setter_method_name do |rhs|
+        if Integer === new_klass
+          v = rhs.to_i
+        elsif new_klass == String
+          v = rhs.to_s
+        elsif new_klass == Symbol
+          v = rhs.to_sym
+        elsif new_klass == :boolean
+          v = !!rhs
+        elsif Proc === new_klass
+          v = new_klass.call v
+        else
+          v = new_klass.new rhs
+        end
+        self.send alias_name, v
+      end
+    end
+  end
+  
+  class Error < RuntimeError; end
+  class ParameterRequired < Error; end 
+  class WrongClass < Error; end 
+  class MustRespondTo < Error; end 
+end
+
+# If Rails isn't around, fake ActiveRecord
+module ActiveRecord; end;
+class ActiveRecord::Base; end

data/lib/named_arguments/class_settings_mixin.rb

@@ -0,0 +1,122 @@
+module NamedArguments
+  module ClassSettingsMixin
+    def self.included target
+      target.class_eval do 
+        include NamedArguments::MethodExtensions
+        extend ClassMethods
+      end
+    end
+    
+    module ClassMethods
+      include NamedArguments::MethodExtensions
+      
+      def self.included target
+        target.class_eval do 
+          include NamedArguments::MethodExtensions
+        end
+      end
+      
+      # Allow you to define 
+      # methods that set a class value hash
+      # and an accessor for that hash.
+      # 
+      # Example:
+      # 
+      #   create_class_settings_method :settings
+      # 
+      # creates:
+      # 
+      # settings:: A class method that allows
+      #            you to set variables
+      # settings?:: The current value of those variables
+      # 
+      #   class BlueCar
+      #     create_class_settings_method :settings
+      #     create_class_settings_method :has_these
+      #   
+      #     settings :color => :blue, :another_settting => 10
+      #     settings :painted => true
+      #     has_these :doors, :windows
+      #     has_these :wheels
+      #   end
+      # 
+      #   class Convertable < BlueCar
+      #     has_these :poptop
+      #   end
+      # 
+      #   BlueCar.color
+      #     => :blue
+      # 
+      #   BlueCar.new.settings?
+      #     => {:color => :blue, :painted => true, :another_settting => 10}
+      def create_class_settings_method name
+        # Build the class methods first
+        l = class_setting_lambda name
+        define_method_with_context name, &l
+        
+        # Allow #name? to be called as an instance method
+        # and default its return value to nil.
+        # This will be replaced on any call to the 
+        # setter.
+        value_name = value_field_identifier(name)
+        instance_method = lambda {nil}
+        define_method value_name, instance_method
+      end
+      
+      protected 
+      
+      # Returns a lambda that will create
+      # two methods:
+      # 
+      # A singleton method on the current object
+      #   that takes multiple parameters and 
+      #   stores their values.  This allows
+      #   you to define methods on the class
+      #   that will save their parameters.
+      # An instance method that returns those
+      #   saved parameters
+      def class_setting_lambda name #:nodoc:
+        value_field_id = value_field_identifier name
+        result = lambda do
+          # Note that this lambda is called
+          # either with a single argument
+          # containing a hash, or an array 
+          # of arguments.
+          |*args|
+          
+          if args.first.kind_of? Hash
+            args = args.first
+          end
+          
+          begin
+            current_value = self.send value_field_id
+            case current_value
+            when Array then val = merge_arrays_of_symbols current_value, args
+            when Hash then val = current_value.merge args
+            else
+              raise RuntimeError.new("Attempting to merge two different kinds of data")
+            end
+          rescue NoMethodError
+            val = args
+          end
+          
+          # Define the class method
+          define_method_with_value value_field_id, val
+          
+          # Define the instance method
+          define_method value_field_id, lambda {val}
+        end
+        result
+      end
+      
+      def value_field_identifier name #:nodoc:
+        return "#{name}?"
+      end
+      
+      def merge_arrays_of_symbols a, b #:nodoc:
+        result = a.map(&:to_sym) + b.map(&:to_sym)
+        result.uniq
+      end
+    end
+  end
+end

data/lib/named_arguments/hash_extended_tools.rb

@@ -0,0 +1,94 @@
+module NamedArguments
+  # Provides several hash utilities.
+  # 
+  # Note that you need to extend your hash with this module:
+  # 
+  #   hash = {}
+  #   hash.extend HashExtendedTools
+  #   hash = hash.exclude :foo, :bar
+  # 
+  # Or create a new class:
+  # 
+  #   class HashWithExtendedTools < Hash
+  #     include HashExtendedTools
+  #   end
+  module HashExtendedTools
+    # Change keys in a hash.
+    # 
+    # Pass in a hash of:
+    # 
+    #   old_key => new_key
+    # 
+    # Any keys matching +old_key+ will be
+    # deleted and a new entry created with
+    # the same value and the new key.
+    def switch_keys args = {}
+      args.each_pair do
+        |old_key, new_key|
+        if self.has_key?(old_key)
+          self[new_key] = self[old_key]
+          delete(old_key)
+        end
+      end
+      self
+    end
+    
+    # Return a new hash not including
+    # keys that are contained in 
+    # +keys_to_exclude+.
+    # 
+    # Keys that match entries in 
+    # +keys_to_exclude+ are deleted if
+    # either they match as string or a 
+    # symbol (created with to_sym).
+    def exclude *keys_to_exclude
+      result = self.dup
+      keys_to_exclude.each do |k|
+        result.delete k.to_s
+        result.delete k.to_sym
+      end
+      result
+    end
+    
+    # Given an array of keys,
+    # return a hash containing
+    # the key/value pairs
+    # for the matching keys.
+    # 
+    # Values that are nil are not
+    # returned.
+    def slice *slice_keys
+      result = {}
+      slice_keys.each do |k|
+        result[k] = self[k] unless self[k].nil?
+      end
+      result
+    end
+    
+    # Return the given attributes as a hash containing
+    # attribute => value pairs.
+    # 
+    #  obj.a = 10
+    #  obj.b = 20
+    #  attributes_as_hash(:a, :b) 
+    #    => {:a => 10, :b => 20}
+    def attributes_as_hash *attrs
+      result = {}
+      attrs.each do |a|
+        v = self.send a
+        result[a] = v unless v.nil?
+      end
+      result
+    end
+    
+    def symbol_keys_as_strings
+      sym_keys = self.keys.select {|k| k.kind_of? Symbol}
+      new_keys = {}
+      sym_keys.each {|k| new_keys[k] = k.to_s}
+      result = dup
+      result.extend HashExtendedTools
+      result.switch_keys new_keys
+      result
+    end
+  end
+end

data/lib/named_arguments/method_extensions.rb

@@ -0,0 +1,51 @@
+module NamedArguments
+  # Adds two methods to a class:
+  # 
+  # define_method_with_context
+  # define_method_with_value
+  module MethodExtensions
+    def self.included target
+      target.class_eval do
+        include ExtendedDefines
+        extend ExtendedDefines
+      end
+    end
+    
+    module ExtendedDefines
+      # Create a method out of a
+      # name and a lambda.
+      # 
+      # Example:
+      # 
+      #   my_lambda = lambda {13}
+      #   define_method_with_context :return_13, my_lambda
+      # 
+      #   assert 13 == self.return_13
+      def define_method_with_context method_name, &block
+        sclass = class << self; self end
+        sclass.send(:define_method, method_name, block)
+        sclass.send(:public, method_name)
+      end
+      
+      # Create a method out of a
+      # value and a name
+      # The method will return the value.
+      # 
+      # Example:
+      # 
+      #   define_method_with_value :return_14, 14
+      # 
+      #   assert 14 == self.return_14
+      def define_method_with_value name, value
+        define_method_with_context name do
+          value
+        end
+      end
+      
+      def define_method_noop name
+        define_method_with_context name do
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/named_arguments'

data/test/unit/named_arguments_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'test/unit'
+
+class NamedArgumentsTest < Test::Unit::TestCase
+  class TestClassAttributeDefaults
+    include NamedArguments
+    attr_accessor :foo, :bar
+    attribute_defaults :foo => 3
+    attribute_defaults :bar => 'bar'
+  end
+  
+  class TestClassRequiredFields
+    include NamedArguments
+    required_fields :foo, :bar
+    attr_accessor :foo, :bar
+  end
+  
+  class TestClassTypeConverter
+    include NamedArguments
+    attr_accessor :foo
+    type_converter :foo, String
+  end
+  
+  #  attribute_defaults :color => 'blue', :size => lambda {|s| some_method_call(s)}
+  #    required_fields :color, :name
+  #    required_respond_to :name => :to_s
+  #    required_kind_of? :size => Fixnum
+  #    type_converter :size => Fixnum
+  def test_attribute_defaults
+    o = TestClassAttributeDefaults.new
+    assert_equal 3, o.foo
+    assert_equal 'bar', o.bar
+    o = TestClassAttributeDefaults.new :bar => 7
+    assert_equal 7, o.bar
+  end
+  
+  def test_required_fields
+    assert_raises NamedArguments::ParameterRequired do
+      o = TestClassRequiredFields.new
+    end
+  end
+  
+  def test_required_respond_to
+  end
+  
+  def type_converter
+    o = TestClassTypeConverter.new :foo => 3
+    assert_equal '3', o.foo
+    
+    o = TestClassTypeConverter.new :foo => 3
+    assert_equal '3', o.foo
+  end
+  
+  def test_includes
+    t = TestClassTypeConverter.new
+    t.define_method_with_value :test_method, 7
+    assert_equal 7, t.test_method
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: named_arguments
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+date: 2007-06-03 00:00:00 -07:00
+summary: The author was too lazy to write a summary
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: http://www.zenspider.com/ZSS/Products/named_arguments/
+rubyforge_project: named_arguments
+description: The author was too lazy to write a description
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ryan Davis
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/named_arguments.rb
+- lib/named_arguments/class_settings_mixin.rb
+- lib/named_arguments/hash_extended_tools.rb
+- lib/named_arguments/method_extensions.rb
+- test/unit/named_arguments_test.rb
+- test/test_helper.rb
+test_files: 
+- test/test_helper.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.1
+    version: