@@ -10,23 +10,23 @@ module Compact
1010 # @return [Array, Hash]
1111 def compact ( element , property = nil )
1212 if property . nil?
13- debug ( "compact" ) { "element: #{ element . inspect } #{ context . inspect } }
13+ log_debug ( "compact" ) { "element: #{ element . inspect } #{ context . inspect } }
1414 else
15- debug ( "compact" ) { "property: #{ property . inspect } }
15+ log_debug ( "compact" ) { "property: #{ property . inspect } }
1616 end
1717 case element
1818 when Array
19- debug ( "" ) { "Array #{ element . inspect } }
20- result = depth { element . map { |item | compact ( item , property ) } . compact }
19+ log_debug ( "" ) { "Array #{ element . inspect } }
20+ result = log_depth { element . map { |item | compact ( item , property ) } . compact }
2121
2222 # If element has a single member and the active property has no
2323 # @container mapping to @list or @set, the compacted value is that
2424 # member; otherwise the compacted value is element
2525 if result . length == 1 && context . container ( property ) . nil? && @options [ :compactArrays ]
26- debug ( "=> extract single element: #{ result . first . inspect } )
26+ log_debug ( "=> extract single element: #{ result . first . inspect } )
2727 result . first
2828 else
29- debug ( "=> array result: #{ result . inspect } )
29+ log_debug ( "=> array result: #{ result . inspect } )
3030 result
3131 end
3232 when Hash
@@ -36,9 +36,9 @@ def compact(element, property = nil)
3636 return nil if element . has_key? ( '@null' )
3737
3838 if element . keys . any? { |k | %w( @id @value ) . include? ( k ) }
39- result = context . compact_value ( property , element , depth : @depth )
39+ result = context . compact_value ( property , element , log_depth : @options [ :log_depth ] )
4040 unless result . is_a? ( Hash )
41- debug ( "" ) { "=> scalar result: #{ result . inspect } }
41+ log_debug ( "" ) { "=> scalar result: #{ result . inspect } }
4242 return result
4343 end
4444 end
@@ -48,61 +48,61 @@ def compact(element, property = nil)
4848
4949 element . each_key do |expanded_property |
5050 expanded_value = element [ expanded_property ]
51- debug ( "" ) { "#{ expanded_property } #{ expanded_value . inspect } }
51+ log_debug ( "" ) { "#{ expanded_property } #{ expanded_value . inspect } }
5252
5353 if %w( @id @type ) . include? ( expanded_property )
5454 compacted_value = [ expanded_value ] . flatten . compact . map do |expanded_type |
55- depth { context . compact_iri ( expanded_type , vocab : ( expanded_property == '@type' ) , depth : @depth ) }
55+ log_depth { context . compact_iri ( expanded_type , vocab : ( expanded_property == '@type' ) , log_depth : @options [ :log_depth ] ) }
5656 end
5757 compacted_value = compacted_value . first if compacted_value . length == 1
5858
5959 al = context . compact_iri ( expanded_property , vocab : true , quiet : true )
60- debug ( expanded_property ) { "result[#{ al } #{ compacted_value . inspect } }
60+ log_debug ( expanded_property ) { "result[#{ al } #{ compacted_value . inspect } }
6161 result [ al ] = compacted_value
6262 next
6363 end
6464
6565 if expanded_property == '@reverse'
66- compacted_value = depth { compact ( expanded_value , '@reverse' ) }
67- debug ( "@reverse" ) { "compacted_value: #{ compacted_value . inspect } }
66+ compacted_value = log_depth { compact ( expanded_value , '@reverse' ) }
67+ log_debug ( "@reverse" ) { "compacted_value: #{ compacted_value . inspect } }
6868 compacted_value . each do |prop , value |
6969 if context . reverse? ( prop )
7070 value = [ value ] if !value . is_a? ( Array ) &&
7171 ( context . container ( prop ) == '@set' || !@options [ :compactArrays ] )
72- debug ( "" ) { "merge #{ prop } #{ value . inspect } }
72+ log_debug ( "" ) { "merge #{ prop } #{ value . inspect } }
7373 merge_compacted_value ( result , prop , value )
7474 compacted_value . delete ( prop )
7575 end
7676 end
7777
7878 unless compacted_value . empty?
7979 al = context . compact_iri ( '@reverse' , quiet : true )
80- debug ( "" ) { "remainder: #{ al } #{ compacted_value . inspect } }
80+ log_debug ( "" ) { "remainder: #{ al } #{ compacted_value . inspect } }
8181 result [ al ] = compacted_value
8282 end
8383 next
8484 end
8585
8686 if expanded_property == '@index' && context . container ( property ) == '@index'
87- debug ( "@index" ) { "drop @index" }
87+ log_debug ( "@index" ) { "drop @index" }
8888 next
8989 end
9090
9191 # Otherwise, if expanded property is @index, @value, or @language:
9292 if %w( @index @value @language ) . include? ( expanded_property )
9393 al = context . compact_iri ( expanded_property , vocab : true , quiet : true )
94- debug ( expanded_property ) { "#{ al } #{ expanded_value . inspect } }
94+ log_debug ( expanded_property ) { "#{ al } #{ expanded_value . inspect } }
9595 result [ al ] = expanded_value
9696 next
9797 end
9898
9999 if expanded_value == [ ]
100- item_active_property = depth do
100+ item_active_property = log_depth do
101101 context . compact_iri ( expanded_property ,
102102 value : expanded_value ,
103103 vocab : true ,
104104 reverse : inside_reverse ,
105- depth : @depth )
105+ log_depth : @options [ :log_depth ] )
106106 end
107107
108108 iap = result [ item_active_property ] ||= [ ]
@@ -111,17 +111,17 @@ def compact(element, property = nil)
111111
112112 # At this point, expanded value must be an array due to the Expansion algorithm.
113113 expanded_value . each do |expanded_item |
114- item_active_property = depth do
114+ item_active_property = log_depth do
115115 context . compact_iri ( expanded_property ,
116116 value : expanded_item ,
117117 vocab : true ,
118118 reverse : inside_reverse ,
119- depth : @depth )
119+ log_depth : @options [ :log_depth ] )
120120 end
121121 container = context . container ( item_active_property )
122122 value = list? ( expanded_item ) ? expanded_item [ '@list' ] : expanded_item
123- compacted_item = depth { compact ( value , item_active_property ) }
124- debug ( "" ) { " => compacted key: #{ item_active_property . inspect } #{ compacted_item . inspect } }
123+ compacted_item = log_depth { compact ( value , item_active_property ) }
124+ log_debug ( "" ) { " => compacted key: #{ item_active_property . inspect } #{ compacted_item . inspect } }
125125
126126 if list? ( expanded_item )
127127 compacted_item = [ compacted_item ] unless compacted_item . is_a? ( Array )
@@ -159,7 +159,7 @@ def compact(element, property = nil)
159159 result . keys . kw_sort . inject ( { } ) { |map , kk | map [ kk ] = result [ kk ] ; map }
160160 else
161161 # For other types, the compacted value is the element value
162- debug ( "compact" ) { element . class . to_s }
162+ log_debug ( "compact" ) { element . class . to_s }
163163 element
164164 end
165165 end
0 commit comments