swift_generator 0.1.2

data/lib/swift_generator/code_generation/swift_file_template.rb

@@ -0,0 +1,499 @@
+#!/usr/bin/env ruby
+
+#
+# The initial part of this file belongs to the ribosome project.
+#
+# Copyright (c) 2014 Martin Sustrik  All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom
+# the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+
+module Ribosome
+
+    # Class Block represents a rectangular area of text.
+    class Block
+
+        attr_accessor :text, :width
+
+        def initialize(s)
+            @text = []
+            @width = 0
+            return if s == nil
+
+            # Split the string into individual lines.
+			start = 0
+			loop do
+				i = s.index("\n", start) || s.size
+				@text << (i == start ? "" : s[start..i - 1])
+                @width = [@width, @text.last.size].max
+				start = i + 1
+				break if start > s.size
+			end
+        end
+
+        # Weld the supplied block to the right side of this block.
+        def add_right(block)
+
+            # Merge the blocks while taking care to add whitespace
+            # where they do not align properly.
+            i = 0
+            for l in block.text
+                if(@text[i])
+                    @text[i] += (" " * (@width - @text[i].size)) + l
+                else
+                    @text << (" " * @width) + l
+                end
+                i += 1
+            end
+
+            # Adjust the overall width of the block.
+            @width += block.width
+            
+        end
+
+        # Weld the supplied block to the bottom side of this block.
+        def add_bottom(block)
+            @text += block.text
+            @width = [@width, block.width].max
+        end
+
+        # Trim the whitespace from the block.
+        def trim()
+
+            # Find the boundaries of the text.
+            top = -1
+            bottom = -1
+            left = -1
+            right = -1
+
+            i = 0
+            for l in @text
+                if(!l.lstrip().empty?)
+                    top = i if top == -1
+                    bottom = i;
+                    if (left == -1)
+                        left = l.size() - l.lstrip().size()
+                    else
+                        left = [left, l.size() - l.lstrip().size()].min
+                    end
+                    if (right == -1)
+                        right = l.rstrip().size()
+                    else
+                        right = [right, l.rstrip().size()].max
+                    end
+                end
+                i += 1
+            end
+
+            # The case of block with no text whatsoever.
+            if bottom == -1
+                @text = []
+                @width = 0
+                return
+            end
+
+            # Strip off the top and bottom whitespace.
+            @text = @text[top..bottom]
+
+            # Strip off the whitespace on the left and on the right.
+            for i in 0..@text.size() - 1
+                @text[i] = @text[i].rstrip()[left..right]
+                @text[i] = "" if @text[i] == nil
+            end
+
+            # Adjust the overall width of the block.
+            @width = (@text.max {|x,y| x.size <=> y.size} || "").size
+
+        end
+
+        def write(out, tabsize)
+            for l in @text
+
+                # If required, replace the initial whitespace by tabs.
+                if(tabsize > 0)
+                    ws = l.size - l.lstrip.size
+                    l = "\t" * (ws / tabsize) +
+                        " " * (ws % tabsize) + l.lstrip
+                end
+
+                # Write an individual line to the output file.
+                out.write(l)
+                out.write("\n")
+            end
+        end
+
+        # Returns offset of the last line in the block.
+        def last_offset()
+            return 0 if @text.empty?
+            return @text.last.size - @text.last.lstrip.size
+        end
+
+    end
+
+    # Size of a tab. If set to zero, tabs are not generated.
+    @tabsize = 0
+
+    # The output file, or, alternativly, stdout.
+    @outisafile = false
+    @out = $stdout
+
+    # This is the ribosome call stack. At each level there is a list of
+    # text blocks generated up to that point.
+    @stack = [[]]
+
+    # Redirects output to the specified file.
+    def Ribosome.output(filename)
+        close()
+        @outisafile = true
+        @out = File.open(filename, "w")
+    end
+
+    # Redirects output to the specified file.
+    # New stuff is added to the existing content of the file.
+    def Ribosome.append(filename)
+        close()
+        @outisafile = true
+        @out = File.open(filename, "a")
+    end
+
+    # Redirects output to the stdout.
+    def Ribosome.stdout()
+        close()
+        @outisafile = false
+        @out = $stdout
+    end
+
+    # Sets the size of the tab.
+    def Ribosome.tabsize(size)
+        @tabsize = size
+    end
+
+    # Flush the data to the currently open file and close it.
+    def Ribosome.close()
+        for b in @stack.last
+            b.write(@out, @tabsize)
+        end
+        @stack = [[]]
+        @out.close() if @outisafile
+    end
+
+    # Adds one . line from the DNA file.
+    def Ribosome.add(line, bind)
+
+        # If there is no previous line, add one.
+        if(@stack.last.empty?)
+            @stack.last << Block.new("")
+        end
+
+        # In this block we will accumulate the expanded line.
+        block = @stack.last.last
+
+        # Traverse the line and convert it into a block.
+        i = 0
+        while true
+            j = line.index(/[@&][1-9]?\{/, i)
+            j = line.size if j == nil
+
+            # Process constant block of text.
+            if (i != j)
+                block.add_right(Block.new(line[i..j - 1]))
+            end
+
+            break if line.size == j
+
+            # Process an embedded expression.
+            i = j
+            j += 1
+            level = 0
+            if (line[j] >= ?1 && line[j] <= ?9)
+                level = line[j].to_i
+                j += 1
+            end
+
+            # Find corresponding }.
+            par = 0;
+            while true
+                if(line[j] == ?{)
+                    par += 1
+                elsif(line[j] == ?})
+                    par -= 1
+                end
+                break if par == 0
+                j += 1
+                if j >= line.size
+                    raise SyntaxError.new("Unmatched {")
+                end
+            end
+
+            # Expression of higher indirection levels are simply brought
+            # down by one level.
+            if(level > 0)
+                if line [i + 1] == ?1
+                    block.add_right(Block.new("@" + line[i + 2..j]))
+                else
+                    line[i + 1] = (line [i + 1].to_i - 1).chr
+                    block.add_right(Block.new(line[i..j]))
+                end
+                i = j + 1
+                next
+            end
+
+            # We are at the lowest level of embeddedness so we have to
+            # evaluate the embedded expression straight away.
+            expr = line[(level == 0 ? i + 2 : i + 3)..j - 1]
+            @stack.push([])
+            val = eval(expr, bind)
+            top = @stack.pop()
+            if(top.empty?)
+                val = Block.new(val.to_s)
+            else
+                val = Block.new("")
+                for b in top
+                    val.add_bottom(b)
+                end
+            end
+            val.trim if line[i] == ?@
+            block.add_right(val)
+            i = j + 1
+        end
+    end
+
+    # Adds newline followed by one . line from the DNA file.
+    def Ribosome.dot(line, bind)
+        @stack.last << Block.new("")
+        add(line, bind)
+    end
+
+    # Adds newline followed by leading whitespace copied from the previous line
+    # and one line from the DNA file.
+    def Ribosome.align(line, bind)
+        if @stack.last.empty?
+            n = 0
+        else
+            n = @stack.last.last.last_offset
+        end
+        @stack.last << Block.new("")
+        add(" " * n, nil)
+        add(line, bind)
+    end
+
+    #  Report an error that happened when executing RNA file.
+    def Ribosome.rethrow(e, rnafile, linemap)
+        i = 0
+        for i in 0..e.backtrace.size - 1
+            l = e.backtrace[i]
+            if l.start_with?(rnafile + ":")
+                stop = l.index(":", rnafile.size + 1) || l.size
+                num = l[rnafile.size + 1..stop - 1].to_i
+                for j in 0..linemap.size - 1
+                    break if linemap[j][0] == nil || linemap[j][0] > num
+                end
+                j -= 1
+                num = num - linemap[j][0] + linemap[j][2]
+                l = "#{linemap[j][1]}:#{num}#{l[stop..-1]}"
+                e.backtrace[i] = l
+            end
+        end
+        raise e
+    end
+
+end
+
+# Escape function for @
+def at()
+    return "@"
+end
+
+# Escape function for &
+def amp()
+    return "&"
+end
+
+# Escape function for /
+def slash()
+    return "/"
+end
+
+################################################################################
+# The code that belongs to the ribosome project ends at this point of the      #
+# RNA file and so does the associated license. What follows is the code        #
+# generated from the DNA file.                                                 #
+################################################################################
+
+$definition_file = nil
+
+require 'fileutils'
+require "swift_generator/version"
+require "swift_generator/code_generation/swift_class_generation"
+
+
+module SwiftGenerator
+
+def write_files_for_definition_set( definition_set )
+    for _, f in definition_set.output_files
+        path = Pathname.new( f.file_path )
+        path.parent.mkpath
+        SwiftGenerator::writeGeneratedFile( f )
+    end
+end
+
+
+module_function :write_files_for_definition_set
+
+# files = YAML::load(File.open(ARGV[0]))
+
+# Templated Output Methods
+def write_element( element )
+  if( element.kind_of? SwiftClass )
+    SwiftGenerator::write_class( element )
+  elsif( element.kind_of? SwiftEnum )
+    SwiftGenerator::write_enum( element )
+  end
+end
+
+module_function :write_element
+
+def writeGeneratedFile( f )
+    return if ( f.is_user_file && File.exist?( f.file_path ))
+
+Ribosome.output( f.file_path )
+
+Ribosome.dot("//", binding)
+Ribosome.dot("//  @{f.file_name}", binding)
+Ribosome.dot("//  @{f.company_name}", binding)
+if $definition_file
+Ribosome.dot("//", binding)
+Ribosome.dot("//  Generated from @{$definition_file} on @{Time.now.strftime(\"%d/%m/%Y %H:%M\")}", binding)
+end
+if f.include_editing_warnings
+    if !f.is_user_file
+Ribosome.dot("//", binding)
+Ribosome.dot("//  WARNING: This entire file is generated. DO NOT EDIT.", binding)
+    else
+Ribosome.dot("//", binding)
+Ribosome.dot("//  This is a user-editable generated file. Delete or rename this file to have a new empty file generated", binding)
+    end
+end
+Ribosome.dot("//", binding)
+Ribosome.dot("//  Copyright (c) @{Time.now.strftime(\"\")} @{f.company_name}, Inc. All rights reserved.", binding)
+Ribosome.dot("//", binding)
+
+    for import_statement in f.import_statements.sort
+Ribosome.dot("&{import_statement}", binding)
+    end
+
+  for element in f.elements
+    SwiftGenerator::write_element(element)
+  end
+end
+
+module_function :writeGeneratedFile
+
+
+def write_enum( e )
+Ribosome.dot("", binding)
+Ribosome.dot("", binding)
+Ribosome.dot("&{e.access_control_modifier}enum @{e.type_name}", binding)
+    if e.inheritance_list.count > 0
+Ribosome.add(" : @{e.inheritance_list.join( \", \" )}", binding)
+    end
+Ribosome.add("  {", binding)
+
+  e.enum_cases.each_with_index do |enum_case, _|
+    enum_case.declaration_lines().each do |declLine|
+Ribosome.dot("    &{declLine}", binding)
+    end
+  end
+
+  e.properties.each_with_index do |prop, i|
+Ribosome.dot("", binding)
+    prop.declaration_lines().each do |declLine|
+Ribosome.dot("    &{declLine}", binding)
+    end
+  end
+
+  SwiftGenerator::write_methods( e.methods )
+Ribosome.dot(" }", binding)
+end
+
+module_function :write_enum
+
+
+def write_class( c )
+Ribosome.dot("", binding)
+Ribosome.dot("", binding)
+Ribosome.dot("&{c.access_control_modifier}class @{c.type_name}", binding)
+    if c.inheritance_list.count > 0
+Ribosome.add(" : @{c.inheritance_list.join( \", \" )}", binding)
+    end
+Ribosome.add("  {", binding)
+
+  SwiftGenerator::write_property_declarations( c.transient_properties, "Transient" )
+  SwiftGenerator::write_property_declarations( c.persistent_properties, "Persistent" )
+
+  SwiftGenerator::write_methods( c.initializers )
+  SwiftGenerator::write_methods( c.methods )
+Ribosome.dot("}", binding)
+
+end
+
+module_function :write_class
+
+
+def write_property_declarations( properties, property_type_label )
+  properties.each_with_index do |prop, i|
+    if i == 0
+Ribosome.dot("", binding)
+Ribosome.dot("    // MARK: @{property_type_label} Properties", binding)
+    end
+    prop.declaration_lines().each do |declLine|
+Ribosome.dot("    &{declLine}", binding)
+    end
+  end
+
+end
+
+module_function :write_property_declarations
+
+
+def write_methods( methods )
+    methods.each_with_index do |m, i|
+        overrideString = m.override ? 'override ' : ''
+Ribosome.dot("", binding)
+    if ! m.comment.nil?
+Ribosome.dot("   &{m.comment}", binding)
+    end
+    args = m.argStr.nil? || m.argStr.empty? ? m.argStr : ' ' + m.argStr + ' '
+Ribosome.dot("   &{overrideString}&{m.access_control_modifier}&{m.func_fragment} @{m.name}(&{args})", binding)
+    if ! (m.returns.nil? || m.returns.length == 0 )
+Ribosome.add(" -> @{m.returns}", binding)
+    end
+Ribosome.add(" {", binding)
+    m.bodyLines.each do |line|
+Ribosome.dot("        &{line}", binding)
+    end
+Ribosome.dot("    }", binding)
+  end
+end
+
+module_function :write_methods
+
+end
+Ribosome.close()
+