RUIC 0.4.6 → 0.5.0

data/lib/ruic/attributes.rb

@@ -1,165 +1,170 @@
-#encoding: utf-8
-class UIC::Property
-	class << self; attr_accessor :default; end
-	def initialize(el); @el = el; end
-	def name; @name||=@el['name']; end
-	def type; @type||=@el['type']; end
-	def formal; @formal||=@el['formalName'] || @el['name']; end
-	def min; @el['min']; end
-	def max; @el['max']; end
-	def description; @desc||=@el['description']; end
-	def default; @def ||= (@el['default'] || self.class.default); end
-	def get(asset,slide)
-		if asset.slide? || asset.has_slide?(slide)
-			asset.presentation.get_attribute(asset,name,slide) || default
-		end
-	end
-	def set(asset,new_value,slide_name_or_index)
-		asset.presentation.set_attribute(asset,name,slide_name_or_index,new_value)
-	end
-	def inspect
-		"<#{type} '#{name}'>"
-	end
-
-	class String < self
-		self.default = ''
-	end
-	MultiLineString = String
-
-	class Float < self
-		self.default = 0.0
-		def get(asset,slide); super.to_f; end
-	end
-	class Long < self
-		self.default = 0
-		def get(asset,slide); super.to_i; end
-	end
-	class Boolean < self
-		self.default = false
-		def get(asset,slide); super=='True'; end
-		def set(asset,new_value,slide_name_or_index)
-			super( asset, new_value ? 'True' : 'False', slide_name_or_index )
-		end
-	end
-	class Vector < self
-		self.default = '0 0 0'
-		def get(asset,slide)
-			VectorValue.new(asset,self,slide,super)
-		end
-		def set(asset,new_value,slide_name_or_index)
-			new_value = new_value.join(' ') if new_value.is_a?(Array)
-			super( asset, new_value, slide_name_or_index )
-		end
-	end
-	Rotation = Vector
-	Color    = Vector
-	Float2   = Vector
-	class Image < self
-		self.default = nil
-		def get(asset,slide)
-			if idref = super
-				result = asset.presentation.asset_by_id( idref[1..-1] )
-				slide ? result.on_slide( slide ) : result
-			end
-		end
-		def set(asset,new_value,slide)
-			raise "Setting image attributes not yet supported"
-		end
-	end
-	class Texture < String
-		def get(asset,slide)
-			if path=super
-				path.empty? ? nil : path.gsub( '\\', '/' ).sub( /^.\// ,'' )
-			end
-		end
-	end
-
-	class ObjectRef < self
-		self.default = nil
-		def get(asset,slide)
-			ref  = super
-			type = :absolute
-			obj  = nil
-			unless ref=='' || ref.nil?
-				type = ref[0]=='#' ? :absolute : :path
-				ref = type==:absolute ? asset.presentation.asset_by_id( ref[1..-1] ) : asset.presentation.at( ref, asset )
-			end
-			ObjectReference.new(asset,self,slide,ref,type)
-		end
-		def set(asset,new_object,slide)
-			get(asset,slide).object = new_object
-		end
-	end
-
-	class ObjectReference
-		attr_reader :object, :type
-		def initialize(asset,property,slide,object=nil,type=nil)
-			@asset    = asset
-			@name     = property.name
-			@slide    = slide
-			@object   = object
-			@type     = type
-		end
-		def object=(new_object)
-			raise "ObjectRef must be set to an asset (not a #{new_object.class.name})" unless new_object.is_a?(UIC::MetaData::AssetBase)
-			@object = new_object
-			write_value!
-		end
-		def type=(new_type)
-			raise "ObjectRef types must be either :absolute or :path (not #{new_type.inspect})" unless [:absolute,:path].include?(new_type)
-			@type = new_type
-			write_value!
-		end
-		private
-		def write_value!
-			path = case @object
-				when NilClass then ""
-				else case @type
-					when :absolute then "##{@object.el['id']}"
-					when :path     then @asset.presentation.path_to( @object, @asset ).sub(/^[^:.]+:/,'')
-					# when :root     then @asset.presentation.path_to( @object ).sub(/^[^:.]+:/,'')
-				end
-			end
-			@asset.presentation.set_attribute( @asset, @name, @slide, path )
-		end
-	end
-
-	Import     = String #TODO: a real class
-	Mesh       = String #TODO: a real class
-	Renderable = String #TODO: a real class
-	Font       = String #TODO: a real class
-	FontSize   = Long
-
-	StringListOrInt = String #TODO: a real class
-
-	class VectorValue
-		attr_reader :x, :y, :z
-		def initialize(asset,property,slide,str)
-			@asset    = asset
-			@property = property
-			@slide    = slide
-			@x, @y, @z = str.split(/\s+/).map(&:to_f)
-		end
-		def setall
-			@property.set( @asset, to_s, @slide )
-		end
-		def x=(n); @x=n; setall end
-		def y=(n); @y=n; setall end
-		def z=(n); @z=n; setall end
-		alias_method :r, :x
-		alias_method :g, :y
-		alias_method :b, :z
-		alias_method :r=, :x=
-		alias_method :g=, :y=
-		alias_method :b=, :z=
-		def inspect
-			"<#{@asset.path}.#{@property.name}: #{self}>"
-		end
-		def to_s
-			to_a.join(' ')
-		end
-		def to_a
-			[x,y,z]
-		end
-	end
-end
+#encoding: utf-8
+class UIC::Property
+	# Each property has a generic default value
+	class << self; attr_accessor :default; end
+
+	# …and instances of a particular property can have their own default value
+	attr_accessor :default
+	def initialize(el); @el = el; end
+	def name; @name||=@el['name']; end
+	def type; @type||=@el['type']; end
+	def formal; @formal||=@el['formalName'] || @el['name']; end
+	def min; @el['min']; end
+	def max; @el['max']; end
+	def description; @desc||=@el['description']; end
+	def default; @default ||= (@el['default'] || self.class.default); end
+	def get(asset,slide)
+		if asset.slide? || asset.has_slide?(slide)
+			asset.presentation.get_attribute(asset,name,slide) || default
+		end
+	end
+	def set(asset,new_value,slide_name_or_index)
+		asset.presentation.set_attribute(asset,name,slide_name_or_index,new_value)
+	end
+	def inspect
+		"<#{type} '#{name}'>"
+	end
+
+	class String < self
+		self.default = ''
+	end
+	MultiLineString = String
+
+	class Float < self
+		self.default = 0.0
+		def get(asset,slide); super.to_f; end
+	end
+	class Long < self
+		self.default = 0
+		def get(asset,slide); super.to_i; end
+	end
+	class Boolean < self
+		self.default = false
+		def get(asset,slide); super=='True'; end
+		def set(asset,new_value,slide_name_or_index)
+			super( asset, new_value ? 'True' : 'False', slide_name_or_index )
+		end
+	end
+	class Vector < self
+		self.default = '0 0 0'
+		def get(asset,slide)
+			VectorValue.new(asset,self,slide,super)
+		end
+		def set(asset,new_value,slide_name_or_index)
+			new_value = new_value.join(' ') if new_value.is_a?(Array)
+			super( asset, new_value, slide_name_or_index )
+		end
+	end
+	Rotation = Vector
+	Color    = Vector
+	Float2   = Vector
+	class Image < self
+		self.default = nil
+		def get(asset,slide)
+			if idref = super
+				result = asset.presentation.asset_by_id( idref[1..-1] )
+				# slide ? result.on_slide( slide ) : result
+				# Getting the asset on a particular slide makes it weird
+			end
+		end
+		def set(asset,new_value,slide)
+			raise "Setting image attributes not yet supported"
+		end
+	end
+	class Texture < String
+		def get(asset,slide)
+			if path=super
+				path.empty? ? nil : path.gsub( '\\', '/' ).sub( /^.\// ,'' )
+			end
+		end
+	end
+
+	class ObjectRef < self
+		self.default = nil
+		def get(asset,slide)
+			ref  = super
+			type = :absolute
+			obj  = nil
+			unless ref=='' || ref.nil?
+				type = ref[0]=='#' ? :absolute : :path
+				ref = type==:absolute ? asset.presentation.asset_by_id( ref[1..-1] ) : asset.presentation.at( ref, asset )
+			end
+			ObjectReference.new(asset,self,slide,ref,type)
+		end
+		def set(asset,new_object,slide)
+			get(asset,slide).object = new_object
+		end
+	end
+
+	class ObjectReference
+		attr_reader :object, :type
+		def initialize(asset,property,slide,object=nil,type=nil)
+			@asset    = asset
+			@name     = property.name
+			@slide    = slide
+			@object   = object
+			@type     = type
+		end
+		def object=(new_object)
+			raise "ObjectRef must be set to an asset (not a #{new_object.class.name})" unless new_object.is_a?(UIC::MetaData::AssetBase)
+			@object = new_object
+			write_value!
+		end
+		def type=(new_type)
+			raise "ObjectRef types must be either :absolute or :path (not #{new_type.inspect})" unless [:absolute,:path].include?(new_type)
+			@type = new_type
+			write_value!
+		end
+		private
+		def write_value!
+			path = case @object
+				when NilClass then ""
+				else case @type
+					when :absolute then "##{@object.el['id']}"
+					when :path     then @asset.presentation.path_to( @object, @asset ).sub(/^[^:.]+:/,'')
+					# when :root     then @asset.presentation.path_to( @object ).sub(/^[^:.]+:/,'')
+				end
+			end
+			@asset.presentation.set_attribute( @asset, @name, @slide, path )
+		end
+	end
+
+	Import     = String #TODO: a real class
+	Mesh       = String #TODO: a real class
+	Renderable = String #TODO: a real class
+	Font       = String #TODO: a real class
+	FontSize   = Long
+
+	StringListOrInt = String #TODO: a real class
+
+	class VectorValue
+		attr_reader :x, :y, :z
+		def initialize(asset,property,slide,str)
+			@asset    = asset
+			@property = property
+			@slide    = slide
+			@x, @y, @z = str.split(/\s+/).map(&:to_f)
+		end
+		def setall
+			@property.set( @asset, to_s, @slide )
+		end
+		def x=(n); @x=n; setall end
+		def y=(n); @y=n; setall end
+		def z=(n); @z=n; setall end
+		alias_method :r, :x
+		alias_method :g, :y
+		alias_method :b, :z
+		alias_method :r=, :x=
+		alias_method :g=, :y=
+		alias_method :b=, :z=
+		def inspect
+			"<#{@asset.path}.#{@property.name}: #{self}>"
+		end
+		def to_s
+			to_a.join(' ')
+		end
+		def to_a
+			[x,y,z]
+		end
+	end
+end

data/lib/ruic/behaviors.rb

@@ -27,6 +27,6 @@ class UIC::Application::Behavior < UIC::Behavior
 	def initialize(application,el)
 		self.owner = application
 		self.el    = el
-		super( application.path_to(src) )
+		super( application.resolve_file_path(src) )
 	end
 end

data/lib/ruic/interfaces.rb

@@ -8,7 +8,7 @@ module UIC::FileBacked
 
 	# @param relative [String] a file path relative to this file.
 	# @return [String] the full path resolved relative to this file.
-	def path_to( relative )
+	def resolve_file_path( relative )
 		File.expand_path( relative.gsub('\\','/'), File.dirname(file) )
 	end
 
@@ -63,6 +63,7 @@ module UIC::ElementBacked
 	end
 
 	module ClassMethods
+		# Add methods to instances of the class which gets/sets from an XML attribute.
 		# @param name [String] the name of an XML attribute to expose.
 		# @param getblock [Proc] a proc to run
 		def xmlattribute(name,getblock=nil,&setblock)
@@ -77,3 +78,24 @@ module UIC::PresentableHash
 		flat_map{ |k,v| [ k, *(v.is_a?(Array) ? v.map{|v2| "\t#{v2.to_s}" } : v) ] }
 	end
 end
+
+# Create an array of rows representing a tree of elements.
+# @param root [Object] the root of the tree.
+# @param children [Block] a block that returns an array of child objects when passed an item in the tree.
+# @return [Array<Array>] array of lines pairing the indent string for the line with the element, or `nil` if the indent line is a separator.
+def UIC.tree_hierarchy( root, &children )
+	queue = [[root,"",true]]
+	[].tap do |results|
+		until queue.empty?
+			item,indent,last = queue.pop
+			kids = children[item]
+			extra = indent.empty? ? '' : last ? '\\-' : '|-'
+			results << [ indent+extra, item ]
+			results << [ indent, nil ] if last and kids.empty?
+			indent += last ? '  ' : '| '
+			parts = kids.map{ |k| [k,indent,false] }.reverse
+			parts.first[2] = true unless parts.empty?
+			queue.concat parts
+		end
+	end
+end

data/lib/ruic/presentation.rb

@@ -21,35 +21,14 @@ class UIC::Presentation
 		@scene = @graph.at('Scene')
 		@logic = @doc.at('Logic')
 
-		@class_by_ref = {}
-		@doc.xpath('/UIP/Project/Classes/*').each do |reference|
-			path = app.path_to(reference['sourcepath'])
-			raise "Cannot find file '#{path}' referenced by #{self.inspect}" unless File.exist?( path )
-			metaklass = case reference.name
-				when 'CustomMaterial'
-					meta = Nokogiri.XML(File.read(path,encoding:'utf-8')).at('/*/MetaData')
-					from = app.metadata.by_name[ 'MaterialBase' ]
-					app.metadata.create_class( meta, from, reference.name )
-				when 'Effect'
-					meta = Nokogiri.XML(File.read(path,encoding:'utf-8')).at('/*/MetaData')
-					from = app.metadata.by_name[ 'Effect' ]
-					app.metadata.create_class( meta, from, reference.name )
-				when 'Behavior'
-					lua  = File.read(path,encoding:'utf-8')
-					meta = lua[ /--\[\[(.+?)(?:--)?\]\]/m, 1 ]
-					meta = Nokogiri.XML("<MetaData>#{meta}</MetaData>").root
-					from = app.metadata.by_name[ 'Behavior' ]
-					app.metadata.create_class( meta, from, reference.name )
-			end
-			@class_by_ref[ "##{reference['id']}" ] = metaklass
-			nil
-		end
-
+		generate_custom_classes
 		rebuild_caches_from_document
 
 		@asset_by_el  = {} # indexed by asset graph element
 		@slides_for   = {} # indexed by asset graph element
 		@slides_by_el = {} # indexed by slide state element
+
+		nil
 	end
 
 	# @return [String] the xml representation of this presentation. Formatted to match UI Composer Studio's formatting as closely as possible (for minimal diffs after update).
@@ -59,6 +38,35 @@ class UIC::Presentation
 		   .sub('"?>','" ?>')
 	end
 
+	# Scan the .uip for custom classes that will be needed to generate assets.
+	# Called once during initial load of the file.
+	# @return [nil]
+	def generate_custom_classes
+		parent_class_name = {
+			'CustomMaterial' => 'MaterialBase',
+			'Effect'         => 'Effect',
+			'Behavior'       => 'Behavior'
+		}
+		@class_by_ref = {}
+		@doc.xpath('/UIP/Project/Classes/*').each do |reference|
+			path = resolve_file_path( reference['sourcepath'] )
+			raise "Cannot find file '#{path}' referenced by #{self.inspect}" unless File.exist?( path )
+			parent_class = app.metadata.by_name[ parent_class_name[reference.name] ]
+			parent_props = parent_class.properties
+			new_defaults = Hash[ reference.attributes.map{ |name,attr| [name,attr.value] }.select{ |name,val| parent_props[name] } ]
+			property_el = case reference.name
+				when 'CustomMaterial', 'Effect'
+					Nokogiri.XML(File.read(path,encoding:'utf-8')).at('/*/MetaData')
+				when 'Behavior'
+					lua  = File.read(path,encoding:'utf-8')
+					meta = lua[ /--\[\[(.+?)(?:--)?\]\]/m, 1 ]
+					Nokogiri.XML("<MetaData>#{meta}</MetaData>").root
+			end
+			@class_by_ref[ "##{reference['id']}" ] = app.metadata.create_class( property_el, parent_class, reference.name, new_defaults )
+		end
+		nil
+	end
+
 	# Update the presentation to be in-sync with the document.
 	# Must be called whenever the in-memory representation of the XML document is changed.
 	# Called automatically by all necessary methods; only necessary if script (dangerously)
@@ -165,13 +173,13 @@ class UIC::Presentation
 	end
 	private :asset_for_el
 
-	# def referenced_files
-	# 	(
-	# 		(images + behaviors + effects + meshes + materials ).map(&:file)
-	# 		+ effects.flat_map(&:images)
-	# 		+ fonts
-	# 	).sort_by{ |f| parts = f.split(/[\/\\]/); [parts.length,parts] }
-	# end
+	def referenced_files
+		(
+			(images + behaviors + effects + meshes + materials ).map(&:file)
+			+ effects.flat_map(&:images)
+			+ fonts
+		).sort_by{ |f| parts = f.split(/[\/\\]/); [parts.length,parts] }
+	end
 
 	# @return [MetaData::Scene] the root scene asset for the presentation.
 	def scene
@@ -536,6 +544,64 @@ class UIC::Presentation
 		end
 	end
 
+	# @return [Array<MetaData::AssetBase>] array of layers in the presentation.
+	def layers; find _type:'Layer'; end
+
+	# @return [Array<MetaData::AssetBase>] array of effects in the presentation.
+	def effects; find _type:'Effect'; end
+
+	# @return [Array<MetaData::AssetBase>] array of groups in the presentation.
+	def groups; find _type:'Group'; end
+
+	# @return [Array<MetaData::AssetBase>] array of cameras in the presentation.
+	def cameras; find _type:'Camera'; end
+
+	# @return [Array<MetaData::AssetBase>] array of lights in the presentation.
+	def lights; find _type:'Light'; end
+
+	# @return [Array<MetaData::AssetBase>] array of components in the presentation (not including the Scene).
+	def components; find _type:'Component'; end
+
+	# @return [Array<MetaData::AssetBase>] array of model nodes in the presentation.
+	def models; find _type:'Model'; end
+	alias_method :meshes, :models
+
+	# @return [Array<MetaData::AssetBase>] array of materials in the presentation (includes Referenced and Custom Materials).
+	def materials
+		# Loop through all assets so that the resulting array of multiple sub-classes is in scene graph order
+		material = app.metadata.by_name['MaterialBase']
+		find.select{ |asset| asset.is_a?(material) }
+	end
+
+	# @return [Array<MetaData::AssetBase>] array of image elements in the presentation.
+	def images; find _type:'Image'; end
+
+	# @return [Array<MetaData::AssetBase>] array of behavior elements in the presentation.
+	def behaviors; find _type:'Behavior'; end
+
+	# @return [Array<MetaData::AssetBase>] array of alias nodes in the presentation.
+	def aliases; find _type:'Alias'; end
+
+	# @return [Array<MetaData::AssetBase>] array of path nodes in the presentation.
+	def paths; find _type:'Path'; end
+
+	# @return [Array<MetaData::AssetBase>] array of path anchor points in the presentation.
+	def anchor_points; find _type:'PathAnchorPoint'; end
+
+	# @return [Array<MetaData::AssetBase>] array of text elements in the presentation.
+	def texts; find _type:'Text'; end
+
+	# @param root [MetaData::AssetBase] the asset to find the hierarchy under.
+	# @return [String] a visual hierarchy under the specified asset.
+	def hierarchy( root=scene )
+		elide = ->(str){ str.length>64 ? str.sub(/(^.{30}).+?(.{30})$/,'\1...\2') : str }
+		hier = UIC.tree_hierarchy(root){ |e| e.children }
+		cols = hier.map{ |i,a| a ? [ [i,a.name].join, a.type, elide[a.path] ] : [i,"",""] }
+		maxs = cols.transpose.map{ |col| col.map(&:length).max }
+		tmpl = maxs.map{ |n| "%-#{n}s" }.join('  ')
+		cols.map{ |a| tmpl % a }.join("\n").prepend("\n").extend(RUIC::SelfInspecting)
+	end
+
 	# @private
 	def inspect
 		"<#{self.class} #{File.basename(file)}>"
@@ -548,8 +614,8 @@ def UIC.Presentation( uip_path=nil )
 	UIC::Presentation.new( uip_path )
 end
 
-# An {Application::Presentation} is a {Presentation} that is associated with a specific `.uia` application.
-# In addition to normal {Presentation} methods it has additional methods related to its presense in the application.
+# An {Application::Presentation Application::Presentation} is a {UIC::Presentation UIC::Presentation} that is associated with a specific `.uia` application.
+# In addition to normal {UIC::Presentation} methods it adds methods related to its presence in the application.
 class UIC::Application::Presentation < UIC::Presentation
 	include UIC::ElementBacked
 	# @!parse extend UIC::ElementBacked::ClassMethods
@@ -577,7 +643,7 @@ class UIC::Application::Presentation < UIC::Presentation
 	def initialize(application,el)
 		self.owner = application
 		self.el    = el
-		super( application.path_to(src) )
+		super( application.resolve_file_path(src) )
 	end
 	alias_method :app, :owner