value 0.1.0 → 0.2.0

data/Rakefile

@@ -1,9 +1,20 @@
 # -*- coding: utf-8 -*-
 
+require 'inventory/rake/tasks'
 require 'lookout/rake/tasks'
-require 'yard'
 
-Lookout::Rake::Tasks::Test.new
-Lookout::Rake::Tasks::Gem.new
-Lookout::Rake::Tasks::Tags.new
-YARD::Rake::YardocTask.new
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'value/version'
+
+Inventory::Rake::Tasks.define Value::Version, :gem => proc{ |_, s|
+  s.author = 'Nikolai Weibull'
+  s.email = 'now@bitwi.se'
+  s.homepage = 'https://github.com/now/value'
+
+  s.add_development_dependency 'yard', '~> 0.7.0'
+
+  s.add_runtime_dependency 'inventory', '~> 0.2.0'
+}
+
+# TODO: Silence warnings generated from YARD (remove this once we plug them)
+Lookout::Rake::Tasks::Test.new :options => []

data/lib/value/comparable.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+module Value::Comparable
+  include Comparable
+
+  def <=>(other)
+    return nil unless self.class == other.class
+    v = nil
+    (values.comparable.any?{ |e| v = (send(e) <=> other.send(e)).nonzero? } and v) or 0
+  end
+
+  alias eql? ==
+end

data/lib/value/values.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+
+class Value::Values
+  include Enumerable
+
+  def initialize(*values)
+    options = Hash === values.last ? values.pop : {}
+    values.pop if @block = values.last.to_s.start_with?('&') ? values.last.to_s[1..-1].to_sym : nil
+    values.pop if @splat = (values.last and values.last.to_s.start_with?('*')) ?
+    values.last.to_s[1..-1].to_sym : nil
+    required, optional = values.partition{ |e| not(Array === e) }
+    @required = required.map(&:to_sym)
+    @optional = optional.map{ |e| [e.first.to_sym, e.last] }
+    all = to_a
+    @comparable = Array === options[:comparable] ?
+      options[:comparable].each{ |e|
+        raise ArgumentError, '%p is not among comparable members %s' % [e, all.map(&:inspect).join(', ')] unless all.include?(e)
+      } :
+      all
+  end
+
+  def each
+    return enum_for(__method__) unless block_given?
+    required.each do |value|
+      yield value
+    end
+    optional.each do |value, _|
+      yield value
+    end
+    yield splat if splat
+    yield block if block
+    self
+  end
+
+  def ==(other)
+    self.class == other.class and
+      required == other.required and
+      optional == other.optional and
+      splat == other.splat and
+      block == other.block
+  end
+
+  attr_reader :required, :optional, :splat, :block, :comparable
+end

data/lib/value/version.rb

@@ -1,5 +1,21 @@
 # -*- coding: utf-8 -*-
 
-class Value
-  Version = '0.1.0'
+require 'inventory'
+
+module Value
+  Version = Inventory.new(0, 2, 0){
+    def libs
+      %w'
+        value/comparable.rb
+        value/values.rb
+      '
+    end
+
+    def additional_libs
+      super +
+        %w'
+          value/yard.rb
+        '
+    end
+  }
 end

data/lib/value/yard.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+require 'yard'
+
+class YARD::Handlers::Ruby::ValuesHandler < YARD::Handlers::Ruby::Base
+  handles method_call('Value')
+  namespace_only
+
+  process do
+    parameters = statement.parameters(false)
+    if YARD::Parser::Ruby::AstNode === parameters[-1][0] and
+        parameters[-1][0].type == :assoc and
+        parameters[-1].jump(:ident).source == 'comparable'
+      parameters.pop
+      ancestor 'Comparable'
+      ancestor 'Value::Comparable'
+    end
+    ancestor 'Value'
+    define('initialize', parameters.map{ |e| [e.jump(:ident).source, e.type == :array ? e[0][1].source : nil] }).
+      docstring.tags(:param).select{ |e| e.text and not e.text.empty? }.each do |e|
+        define e.name.sub(/\A[&*]/, ''), [],
+               '@return [%s] %s' % [e.types.join(', '), e.text], :protected
+        e.text = ''
+      end
+  end
+
+  def ancestor(name)
+    modul = Proxy.new(:root, name).tap{ |m| m.type = :module }
+    namespace.mixins(scope).unshift(modul) unless namespace.mixins(scope).include? modul
+  end
+
+  def define(name, parameters, docstring = nil, visibility = :public)
+    YARD::CodeObjects::MethodObject.new(namespace, name).tap{ |m|
+      register(m)
+      m.signature = 'def %s%s' %
+        [name,
+         parameters.empty? ?
+           '' :
+           '(%s)' % parameters.map{ |n, d| d ? '%s = %s' % [n, d] : n }.join(', ')]
+      m.parameters = parameters
+      m.docstring = docstring if docstring
+      m.visibility = visibility
+    }
+  end
+end
+
+YARD::Handlers::Ruby::MacroHandler::IGNORE_METHODS['Value'] = true

data/lib/value.rb

@@ -1,49 +1,64 @@
 # -*- coding: utf-8 -*-
 
-class Value
-  autoload :Version, 'value/version'
-
-  class << self
-    def values(*values)
-      if values.empty?
-        raise RuntimeError,
-          'no values have been set for class: %p' % self if not defined? @values
-        @values
-      else
-        @values ||= []
-        @values.concat values.map{ |value| value.to_sym }.tap{ |symbols|
-          attr_reader(*symbols)
-          protected(*symbols)
-        }
-      end
-    end
-  end
-
+module Value
   def initialize(*arguments)
     raise ArgumentError,
       'wrong number of arguments (%d for %d)' %
-        [arguments.length, self.class.values.length] if
-          arguments.length != self.class.values.length
-    self.class.values.each_with_index do |value, index|
+        [arguments.length, values.required.length] if
+          arguments.length < values.required.length
+    raise ArgumentError,
+      'wrong number of arguments (%d for %d)' %
+        [arguments.length,
+         values.required.length + values.optional.length] if
+          arguments.length > values.required.length +
+            values.optional.length and not values.splat
+    instance_variable_set :"@#{values.block}",
+      block_given? ? Proc.new : nil if values.block
+    instance_variable_set :"@#{values.splat}",
+      arguments[values.required.length +
+                values.optional.length..-1] if values.splat
+    values.required.each_with_index do |value, index|
       instance_variable_set :"@#{value}", arguments[index]
     end
-    freeze
+    values.optional.each_with_index do |(value, default), index|
+      offset = values.required.length + index
+      instance_variable_set :"@#{value}",
+        offset >= arguments.length ? default : arguments[offset]
+    end
   end
 
   def ==(other)
     self.class == other.class and
-      self.class.values.all?{ |value| send(value) == other.send(value) }
+      values.all?{ |value| send(value) == other.send(value) }
   end
 
   alias eql? ==
 
   def hash
-    self.class.hash ^ self.class.values.map{ |value| send(value) }.hash
+    self.class.hash ^ values.map{ |value| send(value) }.hash
   end
 
   def inspect
     '%s.new(%s)' %
       [self.class,
-       self.class.values.map{ |value| send(value).inspect }.join(', ')]
+       values.map{ |value| send(value).inspect }.join(', ')]
+  end
+
+  load File.expand_path('../value/version.rb', __FILE__)
+  Version.load
+end
+
+class Module
+  def Value(first, *rest)
+    options = Hash === rest.last ? rest.pop : {}
+    values = Value::Values.new(*([first] + rest).push({:comparable => options[:comparable]}))
+    attr_reader(*values)
+    protected(*values)
+    define_method :values do
+      values
+    end
+    private :values
+    include Value::Comparable if options[:comparable]
+    include Value
   end
 end

data/test/unit/value/comparable.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 0 do
+    c = Class.new{ Value(:a, :comparable => true) }
+    c.new(1) <=> c.new(1)
+  end
+
+  expect 0 do
+    c = Class.new{ Value(:a, :b, :comparable => [:a]) }
+    c.new(1, 2) <=> c.new(1, 3)
+  end
+
+  expect ArgumentError.new(':c is not among comparable members :a, :b') do
+    Class.new{ Value(:a, :b, :comparable => [:c]) }
+  end
+end

data/test/unit/value/values.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+end

data/test/unit/value/version.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+end

data/test/unit/value/yard.rb

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+
+require 'value/yard'
+
+Expectations do
+  expect [YARD::CodeObjects::Proxy.new(:root, 'Value')] do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+class A
+  # @param [String] a
+  # @param [Integer] b The b
+  Value(:a, :b)
+end
+EOS
+    YARD::Registry.at('A').mixins(:instance)
+  end
+
+  expect 'Represents As.' do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+class A
+  # Represents As.
+  Value(:a, :b)
+end
+EOS
+    YARD::Registry.at('A#initialize').docstring
+  end
+
+  expect [['a', nil], ['b', '3']] do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+class A
+  Value(:a, [:b, 3])
+end
+EOS
+    YARD::Registry.at('A#initialize').parameters
+  end
+
+  expect [:b, :initialize] do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+class A
+  # @param [String] a
+  # @param [Integer] b The b
+  Value(:a, :b)
+end
+EOS
+    YARD::Registry.all(:method).map(&:name).sort
+  end
+
+  expect [:b, :initialize] do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+class A
+  # @param [String] a
+  # @param [Integer] *b The b
+  Value(:a, :'*b')
+end
+EOS
+    YARD::Registry.all(:method).map(&:name).sort
+  end
+
+  expect [:b, :initialize] do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+class A
+  # @param [String] a
+  # @param [Integer] &b The b
+  Value(:a, :'&b')
+end
+EOS
+    YARD::Registry.all(:method).map(&:name).sort
+  end
+
+  expect nil do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+class A
+  # @param [String] a
+  # @param [Integer] b The b
+  Value(:a, :b)
+end
+EOS
+    YARD::Registry.at('A#a')
+  end
+
+  expect '@return [Integer] The b' do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+class A
+  # @param [String] a
+  # @param [Integer] b The b
+  Value(:a, :b)
+end
+EOS
+    YARD::Registry.at('A#b').docstring.to_raw
+  end
+
+  expect %w'Value Value::Comparable Comparable' do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+class A
+  # @param [String] a
+  Value(:a, :comparable => true)
+end
+EOS
+  YARD::Registry.at('A').inheritance_tree(true)[1..3].map(&:path)
+  end
+
+  expect %w'Value Value::Comparable Comparable' do
+    YARD::Registry.clear
+    YARD::Parser::SourceParser.parse_string(<<EOS)
+module A
+  # @param [String] a
+  Value(:a, :comparable => true)
+end
+class B
+  include A
+  # @param [String] a
+  # @param [String] b
+  Value(:a, :b, :comparable => true)
+end
+EOS
+  YARD::Registry.at('B').inheritance_tree(true)[1..3].map(&:path)
+  end
+end

data/test/unit/value.rb

@@ -1,82 +1,178 @@
 # -*- coding: utf-8 -*-
 
 Expectations do
-  expect RuntimeError.new(/\Ano values have been set for class: /) do
-    Class.new(Value).values
+  expect ArgumentError.new('wrong number of arguments (0 for 1)') do
+    Class.new{ Value(:a) }.new
   end
 
-  expect [:a, :b, :c] do
-    Class.new(Value).values(:a, :b, :c)
+  expect ArgumentError.new('wrong number of arguments (2 for 1)') do
+    Class.new{ Value(:a) }.new(1, 2)
   end
 
-  expect [:a, :b, :c] do
-    Class.new(Value).tap{ |c| c.values :a, :b }.values(:c)
+  expect Value do
+    Class.new{ Value(:a) }.new(1)
+  end
+
+  expect NoMethodError do
+    Class.new{ Value(:a) }.new(1).a
+  end
+
+  expect 1 do
+    Class.new{ Value(:a) }.new(1).instance_eval{ a }
+  end
+
+  expect 1 do
+    Class.new{ Value(:a) }.new(1).instance_variable_get(:@a)
+  end
+
+  expect [] do
+    Class.new{ Value(:'*a') }.new.instance_eval{ a }
+  end
+
+  expect [1, 2, 3] do
+    Class.new{ Value(:'*a') }.new(1, 2, 3).instance_eval{ a }
   end
 
   expect ArgumentError.new('wrong number of arguments (0 for 1)') do
-    Class.new(Value).tap{ |c| c.values :a }.new
+    Class.new{ Value(:a, :'*b') }.new
   end
 
-  expect ArgumentError.new('wrong number of arguments (2 for 1)') do
-    Class.new(Value).tap{ |c| c.values :a }.new(1, 2)
+  expect 1 do
+    Class.new{ Value(:a, :'*b') }.new(1).instance_eval{ a }
   end
 
-  expect Class.new(Value) do |c|
-    c.tap{ |c| c.values :a }.new(1)
+  expect [] do
+    Class.new{ Value(:a, :'*b', :'&c') }.new(1).instance_eval{ b }
   end
 
-  expect true do
-    Class.new(Value).tap{ |c| c.values :a }.new(1).frozen?
+  expect 1 do
+    Class.new{ Value(:a, :'*b') }.new(1, 2, 3).instance_eval{ a }
   end
 
-  expect NoMethodError do
-    Class.new(Value).tap{ |c| c.values :a }.new(1).a
+  expect [2, 3] do
+    Class.new{ Value(:a, :'*b') }.new(1, 2, 3).instance_eval{ b }
+  end
+
+  expect nil do
+    Class.new{ Value(:'&a') }.new.instance_eval{ a }
+  end
+
+  expect 1 do
+    Class.new{ Value(:'&a') }.new{ 1 }.instance_eval{ a.call }
   end
 
   expect 1 do
-    Class.new(Value).tap{ |c| c.values :a }.new(1).instance_eval{ a }
+    Class.new{ Value(:a, :'&b') }.new(1).instance_eval{ a }
+  end
+
+  expect nil do
+    Class.new{ Value(:a, :'&b') }.new(1).instance_eval{ b }
+  end
+
+  expect 1 do
+    Class.new{ Value(:a, :'&b') }.new(1){ 2 }.instance_eval{ a }
+  end
+
+  expect 2 do
+    Class.new{ Value(:a, :'&b') }.new(1){ 2 }.instance_eval{ b.call }
   end
 
   expect 1 do
-    Class.new(Value).tap{ |c| c.values :a }.new(1).instance_variable_get(:@a)
+    Class.new{ Value(:a, :'*b', :'&c') }.new(1).instance_eval{ a }
+  end
+
+  expect [] do
+    Class.new{ Value(:a, :'*b', :'&c') }.new(1).instance_eval{ b }
+  end
+
+  expect nil do
+    Class.new{ Value(:a, :'*b', :'&c') }.new(1).instance_eval{ c }
+  end
+
+  expect 1 do
+    Class.new{ Value(:a, :'*b', :'&c') }.new(1, 2, 3){ 4 }.instance_eval{ a }
+  end
+
+  expect [2, 3] do
+    Class.new{ Value(:a, :'*b', :'&c') }.new(1, 2, 3){ 4 }.instance_eval{ b }
+  end
+
+  expect 4 do
+    Class.new{ Value(:a, :'*b', :'&c') }.new(1, 2, 3){ 4 }.instance_eval{ c.call }
+  end
+
+  expect ArgumentError.new('wrong number of arguments (0 for 1)') do
+    Class.new{ Value(:a, [:b, 2]) }.new
+  end
+
+  expect 1 do
+    Class.new{ Value(:a, [:b, 2]) }.new(1).instance_eval{ a }
+  end
+
+  expect 2 do
+    Class.new{ Value(:a, [:b, 2]) }.new(1).instance_eval{ b }
+  end
+
+  expect ArgumentError.new('wrong number of arguments (3 for 2)') do
+    Class.new{ Value(:a, [:b, 2]) }.new(1, 2, 3)
+  end
+
+  expect 1 do
+    Class.new{ Value(:a, [:b, 2], :'*c') }.new(1, 4, 2).instance_eval{ a }
+  end
+
+  expect 4 do
+    Class.new{ Value(:a, [:b, 2], :'*c') }.new(1, 4, 2).instance_eval{ b }
+  end
+
+  expect [2] do
+    Class.new{ Value(:a, [:b, 2], :'*c') }.new(1, 4, 2).instance_eval{ c }
   end
 
   expect true do
-    c = Class.new(Value).tap{ |c| c.values :a, :b, :c }
+    c = Class.new{ Value(:a, :b, :c) }
     c.new(1, 2, 3) == c.new(1, 2, 3)
   end
 
   expect false do
-    c = Class.new(Value).tap{ |c| c.values :a, :b, :c }
+    c = Class.new{ Value(:a, :b, :c) }
     c.new(1, 2, 3) == c.new(2, 3, 1)
   end
 
   expect true do
-    c = Class.new(Value).tap{ |c| c.values :a, :b, :c }
+    c = Class.new{ Value(:a, :b, :c) }
     c.new(1, 2, 3).eql? c.new(1, 2, 3)
   end
 
   expect false do
-    c = Class.new(Value).tap{ |c| c.values :a, :b, :c }
+    c = Class.new{ Value(:a, :b, :c) }
     c.new(1, 2, 3).eql? c.new(2, 3, 1)
   end
 
   expect true do
-    c = Class.new(Value).tap{ |c| c.values :a, :b, :c }
+    c = Class.new{ Value(:a, :b, :c) }
     c.new(1, 2, 3).hash == c.new(1, 2, 3).hash
   end
 
   expect false do
-    c = Class.new(Value).tap{ |c| c.values :a, :b, :c }
+    c = Class.new{ Value(:a, :b, :c) }
     c.new(1, 2, 3).hash == c.new(2, 3, 1).hash
   end
 
   expect false do
-    c = Class.new(Value).tap{ |c| c.values :a, :b, :c }
+    c = Class.new{ Value(:a, :b, :c) }
     c.new(1, 2, 3).hash == [1, 2, 3].hash
   end
 
   expect(/\A#<Class:0x[[:xdigit:]]+>\.new\(1, 2, 3\)\z/) do
-    Class.new(Value).tap{ |c| c.values :a, :b, :c }.new(1, 2, 3).inspect
+    Class.new{ Value(:a, :b, :c) }.new(1, 2, 3).inspect
+  end
+
+  expect 1 do
+    Class.new{ include Module.new{ Value(:a) } }.new(1).instance_eval{ a }
+  end
+
+  expect [Value, Value::Comparable, Comparable] do
+    Class.new{ Value(:a, :comparable => true) }.ancestors[1..3]
   end
 end

metadata

@@ -1,117 +1,79 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: value
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Nikolai Weibull
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-09-05 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: lookout
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+date: 2012-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &2152363560 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 0
-        version: "2.0"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rbtags
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2152363560
+- !ruby/object:Gem::Dependency
+  name: inventory
+  requirement: &2152363060 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 0
-        - 1
-        - 0
-        version: 0.1.0
-  type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: yard
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        - 7
-        - 0
-        version: 0.7.0
-  type: :development
-  version_requirements: *id003
-description: "                                     Value\n\n  Value is a library for defining value objects in Ruby.\n"
+  version_requirements: *2152363060
+description: ! "                                     Value\n\n  Value is a library
+  for defining value objects in Ruby.\n"
 email: now@bitwi.se
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- lib/value/version.rb
+files:
+- lib/value/comparable.rb
+- lib/value/values.rb
 - lib/value.rb
+- lib/value/version.rb
+- lib/value/yard.rb
+- test/unit/value/comparable.rb
+- test/unit/value/values.rb
 - test/unit/value.rb
+- test/unit/value/version.rb
+- test/unit/value/yard.rb
 - README
 - Rakefile
-has_rdoc: true
-homepage: http://github.com/now/value
+homepage: https://github.com/now/value
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Value is a library for defining value objects in Ruby.
 test_files: []
-