chione 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21a376418607624f09eee0d544f6713a84623e5229e857544fa9029734dd5d77
-  data.tar.gz: b37e5e8a256eed89ac9b5bef9a00174d4c14db4907cea7bb59deaa7dd980238f
+  metadata.gz: 499f4f5ac15a4abdc2e443cc3cb89c0961be6fecb97251e014199cfb0ba82dde
+  data.tar.gz: f0cc3da0ebcb1a8aea02cf10dac2eeb7bd26986df587db3a39238bbff69133a1
 SHA512:
-  metadata.gz: 45852b79b8669cefd557274d2d2af98b84df92c0ba239302966b3bc2057c4c5f41d171f389ac9cbb40726d56297506459130a35eea14fa7f9f4ab7a13f5271ca
-  data.tar.gz: 21d21fd326a4a9641fc13dc2c26d1a507b006a776f9234f266dff12dbbe74cf8c3911317a87017fb39242c05b90df1c342047b857ba27b38b5c5c1366b31762c
+  metadata.gz: bfeda410c67704987bc1b049f9fe2b2521bfce8411d4360d878db767883590b874e165e6c965b68f1181d82fde2305fe36a93fb3d7d9941a2f8b477c97950132
+  data.tar.gz: eeddaa0889e2e6dc59f7c8f9e217a8c6a72902449bab6e7f397b232dfb4da114b07873b1fa6d9a991abecd118ad1403be203983e6c96922d30d9afe7dd666b53

checksums.yaml.gz.sig

@@ -1 +1 @@
-��?F��Յ���	k_I��W*���g����=�;cۥk5����rX�Ε����	��<7�`�t�ۇ��
+��G&/�9�Cߎ�D�h�צ���`>3����
�|SRF�s���,꺅�1��
�0-���D�ϳ�4tu�߲��[6���0?T3����q.��)�}AwQK[��cs��C!�d\
�,�A7�����a�X��m��Z'����e�
Z���Y��<�O�.���+�@&"Ɏ5d��� ��)��|7�O�}����9���J?��Y��&�W{z�u�y�)e�2X���z��3��2,N?y=N=+5q흵q�s� %��:�8U�z��-�J�= B��uDkiݴ�Ȉo^c>�X(� (��!N�cO�Y�b
��Y��_�"-�һ�!H]��?U~��Z�Z��익h�犦��H��(+U�8�{%��Y,^޼&��

data/History.md

@@ -1,3 +1,11 @@
+## v0.9.0 [2018-07-19] Michael Granger <ged@FaerieMUD.org>
+
+Enhancements:
+
+- Make component fields more flexible.
+- Add DataUtilities mixin
+
+
 ## v0.8.0 [2018-07-18] Michael Granger <ged@FaerieMUD.org>
 
 Enhancements:

data/Rakefile

@@ -39,10 +39,9 @@ hoespec = Hoe.spec 'chione' do |spec|
 	spec.dependency 'fluent_fixtures', '~> 0.6'
 	spec.dependency 'faker',           '~> 1.8'
 
-	spec.dependency 'hoe-deveiate',            '~> 1.0',  :developer
+	spec.dependency 'hoe-deveiate',            '~> 0.10',  :developer
 	spec.dependency 'simplecov',               '~> 0.12',  :developer
-	spec.dependency 'rdoc-generator-fivefish', '~> 0.3',  :developer
-	spec.dependency 'rdoc',                    '~> 5.1',  :developer
+	spec.dependency 'rdoc-generator-fivefish', '~> 0.4',  :developer
 
 	spec.require_ruby_version( '>=2.5.0' )
 	spec.hg_sign_tags = true if spec.respond_to?( :hg_sign_tags= )

data/lib/chione.rb

@@ -12,7 +12,7 @@ module Chione
 	extend Loggability
 
 	# Gem version
-	VERSION = '0.8.0'
+	VERSION = '0.9.0'
 
 
 	# Loggability API -- set up a log host

data/lib/chione/component.rb

@@ -32,17 +32,46 @@ class Chione::Component
 	### +default+. If the optional +process_block+ is provided, it will be called
 	### with the new value being assigned to the field before it is set, and the
 	### return value of it will be used instead.
-	def self::field( name, default: nil, &process_block )
+	def self::field( name, **options, &process_block )
+		options[ :processor ] = process_block
 		self.fields ||= {}
-		self.fields[ name ] = default
+		self.fields[ name ] = options
 
-		define_method( "process_#{name}", &process_block ) if process_block
-		define_method( "#{name}=" ) do |new_val|
-			new_val = self.send( "process_#{name}", new_val ) if self.respond_to?( "process_#{name}" )
+		# Add some class method
+		self.define_singleton_method( "processor_for_#{name}" ) do
+			return self.fields.dig( name, :processor )
+		end
+		self.define_singleton_method( "default_for_#{name}" ) do
+			default = self.fields.dig( name, :default )
+			return default.call( self ) if default.respond_to?( :call )
+			return Chione::DataUtilities.deep_copy( default )
+		end
+		self.define_singleton_method( "options_for_#{name}" ) do
+			return self.fields[ name ]
+		end
+
+		# Add instance methods as a mixin so they can be overridden and super()ed to
+		mixin = self.make_field_mixin( name )
+		self.include( mixin )
+
+	end
+
+
+	### Make a mixin module with methods for the field with the specified +name+.
+	def self::make_field_mixin( name )
+		mixin = Module.new
+
+		mixin.attr_reader( name )
+		mixin.define_method( "process_#{name}" ) do |value|
+			processor = self.class.send( "processor_for_#{name}" ) or return value
+			return processor.call( value )
+		end
+		mixin.define_method( "#{name}=" ) do |new_val|
+			new_val = self.send( "process_#{name}", new_val )
 			self.instance_variable_set( "@#{name}", new_val )
 		end
 
-		attr_reader( name )
+		return mixin
 	end
 
 
@@ -56,8 +85,9 @@ class Chione::Component
 		@entity_id = entity_id
 
 		if self.class.fields
-			self.class.fields.each do |name, default|
-				self.method( "#{name}=" ).call( values[name] || default_value(default) )
+			self.class.fields.each_key do |name|
+				val = values[ name ] || self.class.send( "default_for_#{name}" )
+				self.public_send( "#{name}=", val )
 			end
 		end
 	end
@@ -102,20 +132,6 @@ class Chione::Component
 	private
 	#######
 
-	### Process the given +default+ value so it's suitable for use as a default
-	### attribute value.
-	def default_value( default )
-		return default.call( self ) if default.respond_to?( :call )
-		return deep_copy( default )
-	end
-
-
-	### Make a deep copy of the specified +value+.
-	def deep_copy( value )
-		return Marshal.load( Marshal.dump(value) )
-	end
-
-
 	### Return a slice of the specified +string+ truncated to at most +maxlen+
 	### characters. Returns the unchanged +string+ if it's not longer than +maxlen+.
 	def truncate_string( string, maxlen )

data/lib/chione/mixins.rb

@@ -1,6 +1,7 @@
 # -*- ruby -*-
 #encoding: utf-8
 
+require 'tempfile'
 require 'chione' unless defined?( Chione )
 
 
@@ -110,4 +111,90 @@ module Chione
 	end # module Inspection
 
 
+	# A collection of miscellaneous functions that are useful for manipulating
+	# complex data structures.
+	#
+	#   include Chione::DataUtilities
+	#   newhash = deep_copy( oldhash )
+	#
+	module DataUtilities
+
+		###############
+		module_function
+		###############
+
+		### Recursively copy the specified +obj+ and return the result.
+		def deep_copy( obj )
+
+			# Handle mocks during testing
+			return obj if obj.class.name == 'RSpec::Mocks::Mock'
+
+			return case obj
+				when NilClass, Numeric, TrueClass, FalseClass, Symbol,
+				     Module, Encoding, IO, Tempfile
+					obj
+
+				when Array
+					obj.map {|o| deep_copy(o) }
+
+				when Hash
+					newhash = {}
+					newhash.default_proc = obj.default_proc if obj.default_proc
+					obj.each do |k,v|
+						newhash[ deep_copy(k) ] = deep_copy( v )
+					end
+					newhash
+
+				else
+					obj.clone
+				end
+		end
+
+
+		### Create and return a Hash that will auto-vivify any values it is missing with
+		### another auto-vivifying Hash.
+		def autovivify( hash, key )
+			hash[ key ] = Hash.new( &Chione::DataUtilities.method(:autovivify) )
+		end
+
+
+		### Return a version of the given +hash+ with its keys transformed
+		### into Strings from whatever they were before.
+		def stringify_keys( hash )
+			newhash = {}
+
+			hash.each do |key,val|
+				if val.is_a?( Hash )
+					newhash[ key.to_s ] = stringify_keys( val )
+				else
+					newhash[ key.to_s ] = val
+				end
+			end
+
+			return newhash
+		end
+
+
+		### Return a duplicate of the given +hash+ with its identifier-like keys
+		### transformed into symbols from whatever they were before.
+		def symbolify_keys( hash )
+			newhash = {}
+
+			hash.each do |key,val|
+				keysym = key.to_s.dup.untaint.to_sym
+
+				if val.is_a?( Hash )
+					newhash[ keysym ] = symbolify_keys( val )
+				else
+					newhash[ keysym ] = val
+				end
+			end
+
+			return newhash
+		end
+		alias_method :internify_keys, :symbolify_keys
+
+	end # module DataUtilities
+
+
 end # module Chione

data/spec/chione/component_spec.rb

@@ -45,6 +45,9 @@ describe Chione::Component do
 			component_subclass.field( :x, default: 0 )
 			component_subclass.field( :y, default: 18 )
 
+			expect( component_subclass.default_for_x ).to eq( 0 )
+			expect( component_subclass.default_for_y ).to eq( 18 )
+
 			instance = component_subclass.new
 			expect( instance.x ).to eq( 0 )
 			expect( instance.y ).to eq( 18 )
@@ -56,12 +59,22 @@ describe Chione::Component do
 				{ x: Integer(vals[0]), y: Integer(vals[1]) }
 			end
 
+			expect( component_subclass.processor_for_coordinates ).to respond_to( :call )
+
 			instance = component_subclass.new( coordinates: [88, 19] )
 			expect( instance.coordinates[:x] ).to eq( 88 )
 			expect( instance.coordinates[:y] ).to eq( 19 )
 		end
 
 
+		it "can declare a field with arbitrary options" do
+			component_subclass.field( :x, default: 1, serializable: false )
+
+			expect( component_subclass.options_for_x ).to include( serializable: false )
+			expect( component_subclass.default_for_x ).to eq( 1 )
+		end
+
+
 		it "uses a dup of the default if it's not an immediate object" do
 			component_subclass.field( :things, default: [] )
 
@@ -77,10 +90,12 @@ describe Chione::Component do
 		it "calls a callable default if it responds to #call" do
 			component_subclass.field( :oid, default: ->(obj) { obj.object_id } )
 
+			expect( component_subclass.default_for_oid ).to eq( component_subclass.object_id )
+
 			instance1 = component_subclass.new
 			instance2 = component_subclass.new( oid: 121212 )
 
-			expect( instance1.oid ).to eq( instance1.object_id )
+			expect( instance1.oid ).to eq( component_subclass.object_id )
 			expect( instance2.oid ).to eq( 121212 )
 		end
 

data/spec/chione/mixins_spec.rb

@@ -90,5 +90,131 @@ describe Chione, "mixins" do
 	end
 
 
+	describe Chione::DataUtilities do
+
+		it "doesn't try to dup immediate objects" do
+			expect( Chione::DataUtilities.deep_copy( nil ) ).to be( nil )
+			expect( Chione::DataUtilities.deep_copy( 112 ) ).to be( 112 )
+			expect( Chione::DataUtilities.deep_copy( true ) ).to be( true )
+			expect( Chione::DataUtilities.deep_copy( false ) ).to be( false )
+			expect( Chione::DataUtilities.deep_copy( :a_symbol ) ).to be( :a_symbol )
+		end
+
+		it "doesn't try to dup modules/classes" do
+			klass = Class.new
+			expect( Chione::DataUtilities.deep_copy( klass ) ).to be( klass )
+		end
+
+		it "doesn't try to dup IOs" do
+			data = [ $stdin ]
+			expect( Chione::DataUtilities.deep_copy( data[0] ) ).to be( $stdin )
+		end
+
+		it "doesn't try to dup Tempfiles" do
+			data = Tempfile.new( 'strelka_deepcopy.XXXXX' )
+			expect( Chione::DataUtilities.deep_copy( data ) ).to be( data )
+		end
+
+		it "makes distinct copies of arrays and their members" do
+			original = [ 'foom', Set.new([ 1,2 ]), :a_symbol ]
+
+			copy = Chione::DataUtilities.deep_copy( original )
+
+			expect( copy ).to eq( original )
+			expect( copy ).to_not be( original )
+			expect( copy[0] ).to eq( original[0] )
+			expect( copy[0] ).to_not be( original[0] )
+			expect( copy[1] ).to eq( original[1] )
+			expect( copy[1] ).to_not be( original[1] )
+			expect( copy[2] ).to eq( original[2] )
+			expect( copy[2] ).to be( original[2] ) # Immediate
+		end
+
+		it "makes recursive copies of deeply-nested Arrays" do
+			original = [ 1, [ 2, 3, [4], 5], 6, [7, [8, 9], 0] ]
+
+			copy = Chione::DataUtilities.deep_copy( original )
+
+			expect( copy ).to eq( original )
+			expect( copy ).to_not be( original )
+			expect( copy[1] ).to_not be( original[1] )
+			expect( copy[1][2] ).to_not be( original[1][2] )
+			expect( copy[3] ).to_not be( original[3] )
+			expect( copy[3][1] ).to_not be( original[3][1] )
+		end
+
+		it "makes distinct copies of Hashes and their members" do
+			original = {
+				:a => 1,
+				'b' => 2,
+				3 => 'c',
+			}
+
+			copy = Chione::DataUtilities.deep_copy( original )
+
+			expect( copy ).to eq( original )
+			expect( copy ).to_not be( original )
+			expect( copy[:a] ).to eq( 1 )
+			expect( copy.key( 2 ) ).to eq( 'b' )
+			expect( copy.key( 2 ) ).to_not be( original.key(2) )
+			expect( copy[3] ).to eq( 'c' )
+			expect( copy[3] ).to_not be( original[3] )
+		end
+
+		it "makes distinct copies of deeply-nested Hashes" do
+			original = {
+				:a => {
+					:b => {
+						:c => 'd',
+						:e => 'f',
+					},
+					:g => 'h',
+				},
+				:i => 'j',
+			}
+
+			copy = Chione::DataUtilities.deep_copy( original )
+
+			expect( copy ).to eq( original )
+			expect( copy[:a][:b][:c] ).to eq( 'd' )
+			expect( copy[:a][:b][:c] ).to_not be( original[:a][:b][:c] )
+			expect( copy[:a][:b][:e] ).to eq( 'f' )
+			expect( copy[:a][:b][:e] ).to_not be( original[:a][:b][:e] )
+			expect( copy[:a][:g] ).to eq( 'h' )
+			expect( copy[:a][:g] ).to_not be( original[:a][:g] )
+			expect( copy[:i] ).to eq( 'j' )
+			expect( copy[:i] ).to_not be( original[:i] )
+		end
+
+		it "copies the default proc of copied Hashes" do
+			original = Hash.new {|h,k| h[ k ] = Set.new }
+
+			copy = Chione::DataUtilities.deep_copy( original )
+
+			expect( copy.default_proc ).to eq( original.default_proc )
+		end
+
+		it "preserves taintedness of copied objects" do
+			original = Object.new
+			original.taint
+
+			copy = Chione::DataUtilities.deep_copy( original )
+
+			expect( copy ).to_not be( original )
+			expect( copy ).to be_tainted()
+		end
+
+		it "preserves frozen-ness of copied objects" do
+			original = Object.new
+			original.freeze
+
+			copy = Chione::DataUtilities.deep_copy( original )
+
+			expect( copy ).to_not be( original )
+			expect( copy ).to be_frozen()
+		end
+
+	end
+
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chione
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Michael Granger
@@ -35,7 +35,7 @@ cert_chain:
   X0qdrKi+2aZZ0NGuFj9AItBsVmAvkBGIpX4TEKQp5haEbPpmaqO5nIIhV26PXmyT
   OMKv6pWsoS81vw5KAGBmfX8nht/Py90DQrbRvakATGI=
   -----END CERTIFICATE-----
-date: 2018-07-18 00:00:00.000000000 Z
+date: 2018-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: loggability
@@ -197,28 +197,34 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: hoe
   requirement: !ruby/object:Gem::Requirement