sws 0.4

data/lib/sws/cookie.rb

@@ -0,0 +1,27 @@
+module SWS
+
+	
+	# Represents HTML cookie
+	class Cookie
+
+
+		attr_reader :key
+		attr_reader :value
+		attr_reader :path
+
+		#TODO: add domain?
+
+		# Creates new Cookie with given key=value pair and optionally path
+		def initialize ( key, value, path="/" )
+			@key,@value,@path = key,value,path
+		end
+
+
+		# Returns cookie representation in HTTP header form
+		def to_s
+			return "Set-Cookie: #{@key}=#{@value}; path=#{@path}"
+		end
+			
+	end
+
+end

data/lib/sws/direct_action.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+module SWS
+
+	# DirectAction is a way to define multiple entry point to the application.
+	# Default entry point is a default_component defined in application config
+	# file. But sometimes you may need more entry points. In such a situation
+	# create appropiate ..._action methods in your DirectAction class and then you
+	# may access them by using
+	# http://application_url/direct_action_key/method_name_without_action_word
+	# URL.
+	# DirectAction requests are served by instances of this class by default. You
+	# can also define your own classes for this purpose.
+	class DirectAction
+
+		# The Request object the receiver is associated to
+		attr_reader :request
+		
+		def initialize ( request )
+			@request = request
+		end
+
+		# This methods returns default_component instance
+		def default_action ()
+
+			component = Component.create( Application.instance.default_component_class_name, nil, @request )
+			return component.process_request( @request )
+
+		end
+
+		def action_for_name ( name )
+			# TODO: handle non-existing action?
+			return method( name + "_action" ).call()
+		end
+
+	end
+
+end

data/lib/sws/extensions.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+# Extensions to String class - encoding and decoding of URL-encoded string
+class String
+
+
+	# Decode URL-encoded string - returns decoded string.
+	def url_decode ()
+    tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
+      [$1.delete('%')].pack('H*')
+    end
+		
+	end
+
+
+	# Decode URL-encoded string - modifies the receiver. Returns decoded string.
+	def url_decode! ()
+		
+    tr!('+', ' ')
+		gsub!(/((?:%[0-9a-fA-F]{2})+)/n) do
+      [$1.delete('%')].pack('H*')
+    end
+		return self
+		
+	end
+
+
+	# Encode string with URL-encoding - returns encoded string.
+	def url_encode ()
+		
+		gsub(/([^ a-zA-Z0-9_.-]+)/n) do
+      '%' + $1.unpack('H2' * $1.size).join('%').upcase
+    end.tr(' ', '+')
+		
+	end
+
+
+	# Encode string with URL-encoding - modifies the receiver. Returns encoded
+	# string.
+	def url_encode! ()
+		
+		gsub!(/([^ a-zA-Z0-9_.-]+)/n) do
+      '%' + $1.unpack('H2' * $1.size).join('%').upcase
+    end.tr(' ', '+')
+		
+	end
+
+end
+

data/lib/sws/parsers.rb

@@ -0,0 +1,374 @@
+#!/usr/bin/env ruby
+
+# Definition and template parser and helper classes
+module SWS
+	
+	# Class that retrieves definition of the component from .sws and/or .api files.
+	# Parsed definitions are cached to avoid unnecessary overhead.
+	class DefinitionParser
+
+		include Singleton
+	
+		def initialize ()
+			
+			# .sws file cache
+			@sws_cache = Hash.new do |hash,filename|
+				$log_sws_parser.debug( "Parsing .sws #{filename}" )
+				hash[filename] = YAML::load( File.open( filename ) ) #sws_parse( filename )
+			end
+
+			# .api file cache
+			@api_cache = Hash.new do |hash,filename|
+				$log_sws_parser.debug( "Parsing .api #{filename}" )
+				hash[filename] = YAML::load( File.open( filename ) )
+			end
+
+		end
+	
+		
+		# Most important method of the class - returns Component object for given
+		# token in given parent component. Does it by parsing parent definition file
+		# and looking for definition of Component with given token name. When the
+		# definition is found, new Component object with proper slots and definition
+		# (again retrieved from file and parsed) is created.
+		def component_for_token_with_parent ( token, parent )
+		
+			
+			# Element to find - component definition
+			component_definition = nil
+			
+			# Definition is looked for in parent component recursively - up to the
+			# topmost component
+			next_parent = parent
+
+			name = token.sws_name
+			
+			loop do 
+			
+				$log_sws_parser.debug( "Looking for #{name} in #{next_parent}" )
+				
+				# Because this is the parent (so it has children) we don't have to check
+				# if the .sws file is present
+				parent_definition = @sws_cache[ next_parent.definition_filename ]
+				
+				# Definition of component looked for in parent definition - if not
+				# found, the parent's parent will be searched
+				# FIXME: this will surely work incorrectly when 2 nested components have
+				# subcomponents of the same name!
+				component_definition = parent_definition[name]
+				
+				if ( component_definition != nil ) 
+					break
+				elsif ( next_parent.parent != nil )	
+					next_parent = next_parent.parent
+				else
+					raise( "Definiton for component #{name} not found!" )
+				end
+				
+			end	
+
+			$log_sws_parser.debug( "Definition found" )
+	
+			# Create Component object using component_definition hash
+			class_name = component_definition[ "_class" ]
+			unless( class_name )
+				raise( "Cannot find _class attribute for component #{token.sws_name}" )
+			end
+			component = Component.create( class_name, parent.request, name.dup(), parent )
+			component.definition_component = next_parent
+			component.html_attrs = token.attributes
+	
+			slots = Hash.new
+	
+			if ( component.api_filename != nil )
+				@api_cache[ component.api_filename ].each_pair do |slot_name, slot_attrs|
+
+					slot = Slot.new( component, slot_name )
+					slot.bind( component_definition[slot_name] )
+
+					if ( slot_attrs )
+						slot.default = slot_attrs["default"]
+						slot.required = slot_attrs["required"]
+						slot.settable = slot_attrs["settable"]
+					end
+
+					slots[slot_name] = slot
+				end
+			end
+			
+			component.slots = slots
+			component.synchronize_slots()
+			return component
+			
+		end
+	
+	end
+	
+	
+	# Parser for HTML templates of the components. 	
+	class TemplateParser
+	
+		@@file_data = {}
+		
+		# Creates new TemplateParser for given filename.
+		def initialize ( filename )
+			
+			$log_sws_parser.debug( "Creating template parser for name #{filename}" )
+			@template_filename = filename
+						
+		end
+		
+
+		# Main parsing method - parses definition file into the tree of
+		# TemplateToken objects
+		def parse ()
+			
+			begin
+				#TODO: implement debug mode which forces sws to reload
+				# template file every time parse() is called
+				unless( @@file_data[ @template_filename ] )
+					@@file_data[ @template_filename ] = File.read( @template_filename )
+				end
+				template_data = @@file_data[ @template_filename ]
+		
+			rescue Exception
+				raise "Cannot read template data from file \"#{@template_filename}\""
+			end
+			
+			tokenized_data = template_data.scan( /<!--.*?-->|<[^<>]+>|[^<>]+/ )
+			root_token = create_token_tree( tokenized_data )
+			
+			return root_token
+	
+		end
+		
+		
+		private
+
+		# Parses attributes of the tag - used only for SWS tags, so returns null if "sws"
+		# attribute is not found
+		def parse_attributes ( tag )
+
+			attrs = Hash.new
+
+			# Scans tag attrs - matches also attrs with no value, like "selected"
+			# parameter of checkbox or "disabled"
+			tag.scan( /\s+(\w+)\s*=?\s*(['"])(.*?)\2|\s+(\w+)\s*=?\s*([^'"\s>]*)/ ).each do |name,quote,value,second_name,second_value|
+				unless ( name )
+					name = second_name
+					value = second_value
+				end
+				value ||= quote
+				attrs[name.downcase] = value
+			end
+
+			return attrs["sws"] ? attrs : nil
+
+		end
+
+
+		# Creates token tree from the array of lexems
+		def create_token_tree ( lexems )
+
+			nesting_level = 0
+			root_tokens = Array.new
+			current_token = nil
+
+			lexems.reverse.each do |lexem|
+
+				if ( comment?( lexem ) )
+
+					token = TemplateToken.new( current_token,nil,true,true )
+					token.data = lexem
+					if ( current_token )
+						current_token.children << token
+					else
+						root_tokens << token
+					end
+
+				elsif ( closing?( lexem ) )
+
+					tag_name = lexem.scan( /^<\/(\w+)>$/ )[0][0].downcase
+					token = TemplateToken.new( current_token,tag_name )
+					if ( current_token )
+						current_token.children << token
+					else
+						root_tokens << token
+					end
+					current_token = token
+					nesting_level += 1
+
+				elsif ( opening_or_standalone?( lexem ) )
+
+					tag_name = lexem.scan( /^<(\w+)/ )[0][0].downcase
+					if ( current_token && current_token.name == tag_name )		# tag should be closed
+						attrs = parse_attributes( lexem )
+						if ( attrs )
+							current_token.attributes = attrs
+						else
+							# Why should we parse an ordinal tag (attributes etc) and then
+							# generate it again, if we can just put the original lexem?
+							current_token.data = lexem
+						end
+						current_token = current_token.parent
+						nesting_level -= 1
+					else		# standalone tag
+						token = TemplateToken.new( current_token,tag_name,true )
+						attrs = parse_attributes( lexem )
+						if ( attrs )
+							token.attributes = attrs
+						else
+							token.data = lexem
+						end
+						if ( current_token )
+							current_token.children << token
+						else
+							root_tokens << token
+						end
+					end
+
+				else	#text token
+
+					token = TemplateToken.new( current_token,nil,true )
+					token.data = lexem
+					if ( current_token )
+						current_token.children << token
+					else
+						root_tokens << token
+					end
+
+				end
+
+			end
+
+			root_tokens.each { |token| token.reverse() }
+			root_tokens.reverse!
+
+			unless ( nesting_level == 0 ) 
+				raise( "Invalid .html template file - probably some tags are not closed" )
+			end
+			#root_tokens.each { |token| token.dump ( "" ) }
+
+			return root_tokens
+
+		end
+
+
+		# Returns true if the tag is an opening or standalone tag
+		def opening_or_standalone? ( tag )
+			return ( tag =~ /^<\w+/ )
+		end
+
+
+		# Returns true if the tag is a HTML comment
+		def comment? ( tag )
+			return tag =~ /^<!--.*-->$/
+		end
+
+
+		# Returns true if the tag is a closing tag
+		def closing? (tag)
+			return ( tag =~ /^<\/\w+>/ )
+		end
+
+	end
+	
+
+	# Internal class - used only by TemplateParser. Represents a HTML tag or text
+	# token
+	class TemplateToken
+
+		attr_reader :parent, :name, :children
+		attr_accessor :attributes, :data
+
+
+		# Creates new Token with given parent
+		def initialize ( parent,name,standalone=false,comment=false ) 
+
+			@parent = parent
+			@name = name
+			@children = Array.new
+			@comment = comment
+			@standalone = standalone
+			@data = nil
+
+		end
+
+		# Reverses receiver's children array. Used at the end of parsing process, as
+		# parsing is performed backwards (otherwise it is hard to distinguish
+		# open/close and standalone tags)
+		def reverse ()
+			@children.reverse!
+			@children.each { |child| child.reverse() }
+		end
+
+		# Returns true if the receiver represents a Component
+		def sws? ()
+			return @name != nil && @attributes != nil
+		end
+
+		# Returns name of the Component
+		def sws_name ()
+			return @attributes["sws"]
+		end
+
+
+		# Returns true if the receiver represents a HTML tag
+		def tag? ()
+			return @name != nil && @data != nil
+		end
+
+
+		# Returns true if the receiver is a purely text one
+		def text? ()
+			return @name == nil
+		end
+
+
+		# Returns true if the receiver is a HTML comment
+		def comment? ()
+			return @comment
+		end
+
+
+		# Returns true if the receiver is a standalone tag
+		def standalone? ()
+			return @standalone
+		end
+
+
+		# Returns string representation of the receiver
+		def to_s ()
+
+			if( comment? )
+				return "comment"
+			elsif ( text? ) 
+				return "text"
+			elsif( tag? )
+				return "#{data}"
+			else
+				attrs = @attributes.to_a.join( "| " )
+				return "#{@name} #{attrs}"
+			end
+			
+		end
+
+		# Dumps the token recursively in a tree form.
+		def dump ( prefix )
+			if( comment? )
+				puts "#{prefix}comment"
+			elsif ( text? ) 
+				puts "#{prefix}text"
+			elsif( tag? )
+				puts "#{prefix}#{data}"
+				@children.each { |child| child.dump( prefix + " " ) }
+			else
+				attrs = @attributes.to_a.join( "| " )
+				puts "#{prefix}#{@name} #{attrs}"
+				@children.each { |child| child.dump( prefix + " " ) }
+			end
+		end
+
+	end
+
+end