value_struct 0.6.0 → 0.7.0

data/ChangeLog.md

@@ -1,3 +1,8 @@
+### 0.7.0
+* Improve mixin system
+* More logical class/model/inheritance logic
+* Rename Clone mixin to NoClone
+
 ### 0.6.0
 * Fix specs
 * Fix #dup

data/README.md

@@ -4,14 +4,16 @@ A value struct is a subclass of normal [Ruby struct](http://blog.grayproductions
 
 __Value structs are immutable, i.e. they don't have setters (although, not recursively*)__
 
-This gem also provides the following (optional) mixins, to make life easier when using immutable structs:
+Additionally, this gem provides the following optional mixins to make life easier when using immutable structs:
 
-* __DupWithChanges__ #dup takes a optional hash for setting new values
-* __StrictArguments__ Value structs need to be initialized with the exact amount of arguments
-* __Freeze__ Automatically freeze new instances
-* __ToH__ #to_h for converting into a hash (if Ruby version below < 2.0)
+* __:dup_with_changes__ #dup takes a optional hash for setting new values in the duplicate
+* __:to_h__ #to_h for converting into a valuestruct into a hash (if Ruby version below < 2.0)
 
-By default, only the DupWithChanges and ToH mixins get included.
+* __:strict_arguments__ Value structs need to be initialized with the exact amount of arguments
+* __:freeze__ Automatically freezes new instances
+* __:no_clone__ #clone does not clone, but return the same object
+
+By default, only :dup_with_changes and :to_h get included.
 
 ## Why?
 
@@ -19,16 +21,7 @@ Sometimes you want to eliminate state. See [this blog article] for more informat
 
 ## Performance
 
-Without mixins, ValueStructs are as fast as normal structs. Some (optional) mixins add noticable overhead, e.g. StrictArguments
-
-## How to use structs with mixins
-
-    Point = ValueStruct.new_with_mixins :x, :y, [
-      ValueStruct::DupWithChanges,
-      ValueStruct::ToH,
-      ValueStruct::StrictArguments,
-      ValueStruct::Freeze,
-    ]
+Without mixins, ValueStructs are as fast as normal structs. Some (optional) mixins add noticable overhead, e.g. strict_arguments
 
 ## Example
 
@@ -40,6 +33,21 @@ Without mixins, ValueStructs are as fast as normal structs. Some (optional) mixi
 
 Please refer to the [documentation of Ruby's struct] for more details on usage.
 
+## How to use structs with mixins
+
+    Point = ValueStruct.new_with_mixins :x, :y, [
+      ValueStruct::ToH,
+      ValueStruct::Freeze,
+      ValueStruct::DupWithChanges,
+      ValueStruct::StrictArguments,
+    ]
+
+    p = Point.new(1,2)
+    p.to_h       #=> { :x => 1, :y => 2 }
+    p.frozen?    #=> true
+    p.dup(x: 0)  #=> #<ValueStruct Point x=0, y=2>
+    Point.new(1) # ArgumentError
+
 ## *
 
 Because of the nature of Ruby, most things are not really immutable. So if you have an attribute `:by` and initialize it with an array, you cannot change the value struct anymore, but still the array:
@@ -57,8 +65,8 @@ Because of the nature of Ruby, most things are not really immutable. So if you h
 
 ## Influenced by / Thanks to
 
-* Ruby Rogues #123
 * Tom Crayford: [Values](https://github.com/tcrayford/Values)
-* https://github.com/iconara/immutable_struct
+* Theo Hultberg: [ImmutableStruct](https://github.com/iconara/immutable_struct)
+* Ruby Rogues
 
 ## J-_-L

data/lib/value_struct.rb

@@ -1,28 +1,40 @@
 require_relative 'value_struct/version'
-require_relative 'value_struct/core'
+
+require_relative 'value_struct/immutable'
 require_relative 'value_struct/to_h'
 require_relative 'value_struct/dup_with_changes'
 require_relative 'value_struct/strict_arguments'
-require_relative 'value_struct/clone'
+require_relative 'value_struct/no_clone'
 require_relative 'value_struct/freeze'
 
 class ValueStruct < Struct
-  def self.build(*args, &block)
-    struct_class = Struct.new(*args, &block)
-    struct_class.send(:include, ValueStruct::Core)
-    struct_class
-  end
+  class << self
+    alias build new
+
+    def new_with_mixins(*args, mixins, &block)
+      raise ArgumentError, 'mixin list (last paramater) must be an array' unless mixins.is_a? Array
+
+      struct_class = build(*args, &block)
+      struct_class.send(:include, ValueStruct::Immutable)
+
+      mixins.each{ |mixin|
+        if mixin.is_a?(Symbol) # convenient including bundled mixins ala :dup_with_changes
+          mixin = ValueStruct.const_get(mixin.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase })
+        end
+        struct_class.send(:include, mixin)
+      }
+
+      struct_class
+    end
 
-  def self.new_with_mixins(*args, mixins, &block)
-    raise ArgumentError, 'mixin list (last paramater) must be an array' unless mixins.is_a? Array
-    struct_class = build(*args, &block)
-    mixins.each{ |mixin| struct_class.send(:include, mixin) }
-    struct_class
+    def new(*args, &block)
+      mixins = [ValueStruct::DupWithChanges]
+      mixins.unshift(ValueStruct::ToH) if RUBY_VERSION < "2.0"
+      new_with_mixins(*args, mixins, &block)
+    end
   end
 
-  def self.new(*args, &block)
-    mixins = [ValueStruct::DupWithChanges]
-    mixins.unshift(ValueStruct::ToH) if RUBY_VERSION < "2.0"
-    new_with_mixins(*args, mixins, &block)
+  def inspect
+    super.to_s.sub('struct', 'ValueStruct')
   end
 end

data/lib/value_struct/immutable.rb

@@ -0,0 +1,8 @@
+module ValueStruct::Immutable
+  def self.included(struct)
+    struct.send(:undef_method, :"[]=")
+    struct.members.each{ |member|
+      struct.send(:undef_method, :"#{member}=")
+    }
+  end
+end

data/lib/value_struct/no_clone.rb

@@ -0,0 +1,5 @@
+module ValueStruct::NoClone
+  def clone
+    self
+  end
+end

data/lib/value_struct/version.rb

@@ -1,3 +1,3 @@
 class ValueStruct < Struct
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/spec/{clone_spec.rb → no_clone_spec.rb}

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe ValueStruct::Clone do
+describe ValueStruct::NoClone do
   subject do
-    ValueStruct.new_with_mixins(:x, :y, [ValueStruct::Clone]).new(1,2)
+    ValueStruct.new_with_mixins(:x, :y, [ValueStruct::NoClone]).new(1,2)
   end
 
   it{ subject.object_id.should == subject.clone.object_id }

data/spec/value_struct_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe ValueStruct do
+  it "should have a VERSION constant" do
+    ValueStruct.const_get('VERSION').should_not be_empty
+  end
+
+  describe 'struct class initialization and mixins' do
+    subject do
+      ValueStruct
+    end
+
+    describe '.new' do
+      it 'calls .new_with_mixins and adds default mixins' do
+        subject.should_receive(:new_with_mixins).with(
+          :x, :y,  [ValueStruct::ToH, ValueStruct::DupWithChanges]
+        )
+        subject.new(:x, :y)
+      end
+
+      it 'adds the ValueStruct::DupWithChanges mixin' do
+        subject.new(:x, :y).new(1,2).should be_a ValueStruct::DupWithChanges
+      end
+
+      it 'adds ValueStruct::ToH if ruby version is below 2.0' do
+        if RUBY_VERSION < "2.0"
+          subject.new(:x, :y).new(1,2).should be_a ValueStruct::ToH
+        end
+      end
+    end
+
+    describe '.new_with_mixins' do
+      it 'must be initialized with an array as last parameter' do
+        expect{
+          subject.new_with_mixins(:x, :y)
+        }.to raise_error(ArgumentError)
+
+      end
+
+      it 'calls .build without last argument' do
+        mock = subject.build(:x, :y)
+        subject.should_receive(:build).with(
+          :x, :y
+        ).and_return(mock)
+        subject.new_with_mixins(:x, :y, [])
+      end
+
+      it 'always includes ValueStruct::Immutable in a new struct' do
+        subject.new_with_mixins(:x, :y, []).new(1,2).should be_a ValueStruct::Immutable
+      end
+
+      it 'includes all mixins that are given in the last paramater array' do
+        mixins = [
+          ValueStruct::DupWithChanges,
+          ValueStruct::ToH,
+          ValueStruct::StrictArguments,
+          ValueStruct::Freeze,
+        ]
+        res = subject.new_with_mixins(:x, :y, mixins).new(1,2)
+        mixins.each{ |mixin|
+          res.should be_a mixin
+        }
+      end
+
+      it 'converts mixins given as symbols to sub-modules of ValueStruct' do
+        subject.new_with_mixins(
+          :x, :y, [:dup_with_changes]
+        ).should include(ValueStruct::DupWithChanges)
+      end
+    end
+
+    describe '.build' do
+      it 'creates a class that creates value structs' do
+        subject.build(:x, :y).new(1,2).should be_a ValueStruct
+      end
+    end
+  end
+
+  describe 'instance (value) struct behavior' do
+    subject do
+      Point = ValueStruct.new(:x, :y)
+      Point.new(1,2)
+    end
+
+    it { should be_a Struct }
+    it { should be_a ValueStruct::Immutable }
+
+    it 'stores values accessible by readers' do
+      subject.x.should == 1
+      subject.y.should == 2
+    end
+
+    it 'does not define setters' do
+      expect{ subject.x = 5 }.to raise_error(NoMethodError)
+    end
+
+    it 'does not allow mutatation using []= syntax' do
+      expect{ subject[:x] = 5 }.to raise_error(NoMethodError)
+    end
+
+    it 'can be inherited from to add methods' do
+      class GraphPoint < ValueStruct.new(:x, :y)
+        def inspect
+          "GraphPoint at #{x},#{y}"
+        end
+      end
+
+      c = GraphPoint.new(0,0)
+      c.inspect.should == 'GraphPoint at 0,0'
+    end
+
+    describe '#hash and equality' do
+      Y = ValueStruct.new(:x, :y)
+
+      it 'is equal to another value with the same fields' do
+        Point.new(0,0).should == Point.new(0,0)
+      end
+
+      it 'is not equal to an object with a different class' do
+        Point.new(0,0).should_not == Y.new(0,0)
+      end
+
+      it 'is not equal to another value with different fields' do
+        Point.new(0,0).should_not == Point.new(0,1)
+        Point.new(0,0).should_not == Point.new(1,0)
+      end
+
+      it 'has an equal hash if the fields are equal' do
+        p = Point.new(0,0)
+        p.hash.should == Point.new(0,0).hash
+      end
+
+      it 'has a non-equal hash if the fields are different' do
+        p = Point.new(0,0)
+        p.hash.should_not == Point.new(1,0).hash
+      end
+
+      it 'does not have an equal hash if the class is different' do
+        Point.new(0,0).hash.should_not == Y.new(0,0).hash
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: value_struct
 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: 2012-11-03 00:00:00.000000000 Z
+date: 2012-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -191,21 +191,21 @@ files:
 - Rakefile
 - gemspec.yml
 - lib/value_struct.rb
-- lib/value_struct/clone.rb
-- lib/value_struct/core.rb
 - lib/value_struct/dup_with_changes.rb
 - lib/value_struct/freeze.rb
+- lib/value_struct/immutable.rb
+- lib/value_struct/no_clone.rb
 - lib/value_struct/strict_arguments.rb
 - lib/value_struct/to_h.rb
 - lib/value_struct/version.rb
 - spec/benchmark.rb
-- spec/clone_spec.rb
 - spec/dup_with_changes_spec.rb
 - spec/freeze_spec.rb
+- spec/no_clone_spec.rb
 - spec/spec_helper.rb
 - spec/strict_arguments_spec.rb
-- spec/struct_value_spec.rb
 - spec/to_h_spec.rb
+- spec/value_struct_spec.rb
 - value_struct.gemspec
 homepage: https://github.com/janlelis/value_struct
 licenses:

data/lib/value_struct/clone.rb

@@ -1,5 +0,0 @@
-module ValueStruct::Clone
-  def clone
-    self
-  end
-end

data/lib/value_struct/core.rb

@@ -1,12 +0,0 @@
-module ValueStruct::Core
-  def inspect
-    super.to_s.sub('struct', 'ValueStruct')
-  end
-
-  def self.included(struct)
-    struct.send(:undef_method, "[]=".to_sym)
-    struct.members.each do |member|
-      struct.send(:undef_method, "#{member}=".to_sym)
-    end
-  end
-end

data/spec/struct_value_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-describe ValueStruct do
-  describe 'general behavior' do
-    subject do
-      ValueStruct.new(:x, :y)
-    end
-
-    it "should have a VERSION constant" do
-      ValueStruct.const_get('VERSION').should_not be_empty
-    end
-
-    it 'creates Class instances' do
-      should be_instance_of Class
-    end
-  end
-
-  describe 'instance' do
-    subject do
-      Point = ValueStruct.new(:x, :y)
-      Point.new(1,2)
-    end
-
-    it { should be_a Struct }
-    it { should be_a ValueStruct::Core }
-
-    it 'stores values accessible by readers' do
-      subject.x.should == 1
-      subject.y.should == 2
-    end
-
-    it 'does not define setters' do
-      expect{ subject.x = 5 }.to raise_error(NoMethodError)
-    end
-
-    it 'does not allow mutatation using []= syntax' do
-      expect{ subject[:x] = 5 }.to raise_error(NoMethodError)
-    end
-
-    it 'can be inherited from to add methods' do
-      class GraphPoint < ValueStruct.new(:x, :y)
-        def inspect
-          "GraphPoint at #{x},#{y}"
-        end
-      end
-
-      c = GraphPoint.new(0,0)
-      c.inspect.should == 'GraphPoint at 0,0'
-    end
-  end
-
-  describe '#hash and equality' do
-    Y = ValueStruct.new(:x, :y)
-
-    it 'is equal to another value with the same fields' do
-      Point.new(0,0).should == Point.new(0,0)
-    end
-
-    it 'is not equal to an object with a different class' do
-      Point.new(0,0).should_not == Y.new(0,0)
-    end
-
-    it 'is not equal to another value with different fields' do
-      Point.new(0,0).should_not == Point.new(0,1)
-      Point.new(0,0).should_not == Point.new(1,0)
-    end
-
-    it 'has an equal hash if the fields are equal' do
-      p = Point.new(0,0)
-      p.hash.should == Point.new(0,0).hash
-    end
-
-    it 'has a non-equal hash if the fields are different' do
-      p = Point.new(0,0)
-      p.hash.should_not == Point.new(1,0).hash
-    end
-
-    it 'does not have an equal hash if the class is different' do
-      Point.new(0,0).hash.should_not == Y.new(0,0).hash
-      debugger
-    end
-  end
-end