named_value_class 0.6.0 → 0.7.0

data/lib/named_value_class.rb

@@ -1,13 +1,45 @@
 require 'delegate'
+require 'named_value_class/core_ext'
+
+module NamedValueClass
+  OPERATIONS = {}
+  # OPERATORS = %w{+ - / * ** % | & ^ << >>}
+  OPERATORS = %w{+ - / *} # **}
+  
+  def self.operators(klass, op, rhs_class, policy)
+    rhs_class = rhs_class.sub(/^Kernel::/,'')
+    OPERATIONS[klass] ||= {}
+    OPERATIONS[klass][rhs_class] ||= {}
+    OPERATIONS[klass][rhs_class][op] = policy
+  end
+
+  def self.operate(klass, op, rhs_class, lhs, default_policy, rhs)
+    rhs_class = rhs_class.sub(/^Kernel::/,'')
+    result = (OPERATIONS[klass] && OPERATIONS[klass][rhs_class] &&
+              OPERATIONS[klass][rhs_class][op]) ?
+             OPERATIONS[klass][rhs_class][op].call(lhs,default_policy,rhs) :
+             default_policy.call(rhs)
+    result = (result.constrain(lhs.lhs_constrain) rescue result)
+    lhs.class[result] || result
+  end
+end
 
 # see README for documention
 def NamedValueClass(attrs={},&block)
   klass_name, superclass = attrs.first
   attrs.delete(klass_name)
+  lhs_constrain = attrs.delete(:constrain)
   target = (self.class == Object ? Kernel : self)
-  
   target.module_eval "class #{klass_name} < DelegateClass(superclass); end"
   klass = target.const_get(klass_name)  
+
+  if superclass.ancestors.include?(Numeric) && lhs_constrain
+    klass.module_eval <<-EVAL
+      def lhs_constrain
+        #{lhs_constrain}
+      end
+    EVAL
+  end
   
   klass.module_eval do
     def self.inherited(child)
@@ -34,16 +66,102 @@ def NamedValueClass(attrs={},&block)
         end
       end
     end
+    
+    def self.all_operators_with_a *attrs
+      rhs_class = attrs.shift
+      operators *(NamedValueClass::OPERATORS + [rhs_class] + attrs)
+    end
+    
+    def self.all_remaining_operators_with_a *attrs
+    end
+    
+    def self.operators *attrs, &block
+      policy = attrs.pop if attrs.last.is_a?(Hash) 
+      with_a = attrs.pop
+      attrs.each do |op|
+        operator op, *([with_a, policy].compact), &block
+      end
+    end
+    
+    def self.operator op, rhs_class, attrs={}, &policy
+      if value_to_return = (attrs[:return] || attrs[:returns])
+        policy = proc do |_,_,_|
+          value_to_return
+        end
+      end
+      if klass_to_raise = (attrs[:raise] || attrs[:raises])
+        policy = proc do |_,_,_|
+          raise klass_to_raise
+        end
+      end
+      NamedValueClass.operators(self, op, rhs_class.to_s, policy)
+    end
+
+    def self.plus_a         (*attrs,&policy) operator '+', *attrs, &policy end
+    def self.minus_a        (*attrs,&policy) operator '-', *attrs, &policy end
+    def self.divided_by_a   (*attrs,&policy) operator '/', *attrs, &policy end
+    def self.multiplied_by_a(*attrs,&policy) operator '*', *attrs, &policy end
+    def self.modulus_a      (*attrs,&policy) operator '%', *attrs, &policy end
+    def self.raised_by_a    (*attrs,&policy) operator '**',*attrs, &policy end
+
+    {
+     _plus:  '+',
+     _minus: '-',
+     _multi: '*',
+     _divide:'/',
+     _mod:   '%',
+     _raise: '**'
+    }.each do |(name,orig)|
+      eval "alias #{name} #{orig}" rescue nil
+      define_method orig do |rhs|
+        NamedValueClass.operate(self.class,orig,rhs.class.to_s,
+                                self,method(name.to_sym),rhs)
+      end
+    end
+
+    # TODO: think about coerce more
+    # def coerce(lhs)
+    #   [lhs,self.value]
+    # end
+         
+    # def coerce(rhs)
+    #   class_eval do 
+    #     if @operators && @operators[rhs.class]
+    #       @operators[rhs.class].call(self,rhs)
+    #     end
+    #   end
+    # end
   
+    attr_reader :value
+    
     def initialize(attrs = {})
       @name, value = attrs.first
       attrs.delete(@name)
       @name = @name.to_s
-      super(value)
-      
+      super(@value = value)
+
+      this = self
       attrs.each do |(attr,val)|
         self.class.instance_eval do
           attr_accessor attr
+          if [FalseClass,TrueClass].include?(val.class)
+            booleans = begin
+              const_get((attr.to_s+'s').upcase)
+            rescue NameError
+              const_set((attr.to_s+'s').upcase, {})
+            end
+            
+            booleans[value] = this if val
+            
+            self.class.instance_eval do
+              define_method(attr.to_s + 's') do
+                const_get((attr.to_s+'s').upcase)
+              end
+            end
+            define_method "is_#{attr}?" do
+              self.send(attr)
+            end
+          end
         end
         instance_variable_set "@#{attr}", val 
       end

data/lib/named_value_class/core_ext.rb

@@ -0,0 +1,68 @@
+# 
+#  core_ext.rb: useful additions to basic Ruby objects
+#  
+#  Copyright October 2010, Adam Florin. All rights reserved.
+# 
+
+
+# Monkeypatch Array so we can cleanly get SUM
+#
+class Array
+  def sum
+    inject( nil ) { |sum,x| sum ? sum+x : x }
+  end
+end
+
+# So that we can do the neat Railsy syntax like array.map(&:method) in Ruby 1.8.6
+# See http://jlaine.net/2008/5/8/amp-lified
+#
+class Symbol
+  def to_proc
+    lambda {|i| i.send(self)}
+  end
+end
+
+# Numeric extensions
+#
+class Numeric
+  
+  # constrain number within a given range
+  # 
+  def constrain(range)
+    if self > range.end
+      return range.end
+    elsif self < range.begin
+      return range.begin
+    else
+      return self
+    end
+  end
+  
+  # to manage things like timescale shifts which for now 
+  # must be divisible by 2
+  # 
+  def round_to_power(power = 2)
+    power ** (Math.log(self) / Math.log(power)).round
+  end
+end
+
+# To convert :symbol_names to ClassNames and back.
+# 
+class String
+  def camelize
+    self.gsub(/[^_]+/){|c| c.capitalize}.gsub('_', '')
+  end
+  
+  def underscorize
+    self.gsub(/[A-Z]/, "_\\0").gsub(/^_/, '').downcase
+  end
+end
+
+# for Rails-like method chaining
+# 
+class Module
+  def alias_method_chain(target, feature)
+    alias_method "#{target}_without_#{feature}", target
+    alias_method target, "#{target}_with_#{feature}"
+  end
+end

data/lib/named_value_class/immutable.rb

@@ -0,0 +1,9 @@
+module NamedValueClass
+  module Immutable
+    # %w[= += -= *= /= **= %= |= ^= &= <<= >>= &&= ||=].each do |op|
+    #   define_method op do |rhs|
+    #     raise SyntaxError
+    #   end
+    # end
+  end
+end

data/lib/named_value_class/version.rb

@@ -0,0 +1,3 @@
+module NamedValueClass
+  VERSION = '0.7.0'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: named_value_class
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-18 00:00:00.000000000Z
+date: 2011-12-20 00:00:00.000000000Z
 dependencies: []
 description: Quickly add customizable class delegate constants which output their
   names, not their values.  This may be desirable for some DSLs.
@@ -19,6 +19,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/named_value_class.rb
+- lib/named_value_class/core_ext.rb
+- lib/named_value_class/immutable.rb
+- lib/named_value_class/version.rb
 homepage: http://github.com/mgarriss/named_value_class
 licenses: []
 post_install_message: