talk 2.0.1 → 2.0.2

data/lib/contexts/target.rb

@@ -0,0 +1,11 @@
+property :name
+
+tag_description
+tag :language, :class => :string
+tag :destination, :class => :string
+tag :map, :multi => true
+tag :meta, :multi => true, :unique => :name
+tag :rootclass, :class => :string
+tag :template, :class => :string
+tag :prune, :class => :boolean
+tag_end

data/lib/contexts/term.rb

@@ -0,0 +1,11 @@
+property :name
+property :value, :length => [0,nil]
+
+tag_description :bridge => false, :required => false
+tag_end
+
+postprocess lambda { |ctx|
+  if ctx[:value].nil? or ctx[:value].length == 0 then
+    ctx[:value] = ctx[:name]
+  end
+}

data/lib/languages/java/java.rb

@@ -0,0 +1,145 @@
+require 'set'
+
+def make_source
+  types = [ :class, :enumeration, :glossary]
+  types.each do |type|
+    @base[type].each do |current|
+      @current = current
+      @current[:field] ||= [] if type == :class
+      generate_template(filename_for_entity(@current), type.to_s+".java.erb")
+    end
+  end
+end
+
+def filename_for_entity(name)
+  name = name[:name] if name.is_a? Hash
+  name.gsub(".", "/") + ".java"
+end
+
+def autogenerated_warning
+  <<-AUTOGEN_DONE
+/* Autogenerated from Talk
+** Please do not edit this file directly. Instead, modify the underlying .talk files. */
+  AUTOGEN_DONE
+end
+
+def definition_reference(tag)
+  "@talkFile #{tag[:__meta][:file]}:#{tag[:__meta][:line]}"
+end
+
+def rootclass
+  @target[:rootclass] || "io.usetalk.TalkObject"
+end
+
+def superclass(cls)
+  cls[:inherits] || rootclass
+end
+
+def class_package(cls)
+  cls[:name].split(".")[0..-2].join(".")
+end
+
+def list_references_for_class(cls)
+  references = Set.new
+  cls[:field].each do |field|
+    unless is_primitive?(field[:type].first) then
+      references.add(field[:type])
+    end
+  end
+
+  references.to_a
+end
+
+def import_classes
+  (list_references_for_class(@current).map { |name| "import #{name};"}).join("\n")
+end
+
+def comment_block(tag, indent_level=0)
+  lines = []
+  indent = "\t" * indent_level
+  lines.push(indent + "/*!")
+  lines.push(wrap_text_to_width(tag[:description], 80, indent + " *  ")) unless tag[:description].nil?
+  lines.push(indent + " *  ")
+  lines.push(indent + " *  " + definition_reference(tag))
+  lines.push(indent + " */")
+
+  lines.join("\n")
+end
+
+def detail_comment_block(cls)
+  lines = []
+  lines.push("\t/**")
+  lines.push("\t *  #{truncated_name cls[:name]}")
+  cls[:field].each { |f| lines.push("\t *  @param #{field_datatype f} #{f[:name]}") }
+  lines.join("\n")
+end
+
+def field_datatype_rec(field, stack)
+  return field_datatype_basic(field, stack.last) if stack.length == 1
+  t = stack.last
+
+  r = field_datatype_rec(field, stack[0 .. -2])
+  if is_array? t then
+    "[]"
+  elsif is_dict? t then
+    "Map<String, #{r}>"
+  else
+    nil
+  end
+end
+
+def field_datatype_basic(field, type)
+  if is_primitive? type then
+    case type
+    when "string"
+      "String"
+    when "real"
+      "double"
+    when "bool"
+      "boolean"
+    when "object"
+      "Object"
+    when "talkobject"
+      "TalkObject"
+    else
+      size = integer_size(type)
+      size *= 2 if is_unsigned? type # java has no unsigned type; just use the next size up
+      case 
+      when 8
+        "byte"
+      when 16
+        "short"
+      when 32
+        "int"
+      when 64
+        "long"
+      when 128
+        "BigDecimal"
+      end
+    end
+  else
+    truncated_name type
+  end
+end
+
+def field_datatype(field)
+  field_datatype_rec(field, field[:type])
+end
+
+def field_variable(field)
+  lines = []
+  lines.push comment_block(field, 1)
+  lines.push "\tprotected #{field_datatype(field)} #{field[:name]};"
+  lines.join("\n")
+end
+
+def field_accessors(field)
+  lines.push wrap_text(field[:description], " *  ", 1)
+  lines.push field[:deprecated] if field.has_key? :deprecated
+  lines.push definition_reference(field)
+  lines.push " * @param #{field[:name]} #{field[:description]}"
+  lines.push "\tpublic void #{setter_name(field)}(#{field_datatype(field)} #{field[:name]}) {"
+  lines.push "\t\tthis.#{field[:name]} = #{field[:name]}"
+  lines.push "\t}"
+  lines.join "\n"
+end

data/lib/languages/java/templates/class.java.erb

@@ -0,0 +1,22 @@
+<%= autogenerated_warning %>
+package <%= class_package(@current) %>;
+<%= import_classes %>
+
+<%= comment_block(@current) %>
+public class <%= truncated_name(@current) %> extends <%= superclass(@current) %>
+{
+<%= detail_comment_block(@current) %>
+    /**
+     *  <%= truncated_name @current %> - Default Constructor 
+     * 
+     */
+     public <%= truncated_name @current %>() {}
+<%= 
+    (@current[:field].map do |f|
+        field_variable(f)
+    end).join("\n")
+
+    (@current[:field].map do |f|
+        field_accessors(f)
+    end).join("\n")
+%>}

data/lib/languages/java/templates/enumeration.java.erb

@@ -0,0 +1,10 @@
+<%= autogenerated_warning %>
+package <%= class_package(@current) %>;
+
+<%= comment_block(@current) %>
+public class <%= truncated_name(@current) %> extends <%= rootclass %>
+{<% @current[:field].each do |field| %>
+    // <%= field[:description] %>
+    @TalkDescription(description = "<%= field[:description] %>")
+    public final static int <%= field[:name] %> = <%= field[:value] %>;
+<%= end %>}

data/lib/languages/java/templates/glossary.java.erb

@@ -0,0 +1,8 @@
+<%= autogenerated_warning %>
+package <%= class_package(@current) %>;
+
+<%= comment_block(@current) %>
+public class <%= truncated_name(@current) %>
+{<%= @current[:field].each do |field| %>
+  public final static String <%= field[:name] %> = "<%= field[:value] %>";<% end %>
+}

data/lib/languages/language.rb

@@ -0,0 +1,172 @@
+require 'erb'
+require 'fileutils'
+
+def classname_for_filename(name) # /path/to/file_name.rb to FileName
+  File.basename(name.to_s, ".rb").split('_').collect { |word| word.capitalize }.join("")
+end
+
+def is_primitive?(type)
+  primitives = [
+    "uint8", "uint16", "uint32", "uint64",
+    "int8", "int16", "int32", "int64",
+    "string", "real", "bool", "object", "talkobject" ]
+  primitives.include? type
+end
+
+module Talk
+  class Language
+    attr_reader :supported_languages
+
+    class << self
+      def path_for_language(lang)
+        File.absolute_path(File.join(File.dirname(__FILE__), "#{lang}/#{lang}.rb"))
+      end
+
+      def load_supported_languages
+        @languages ||= {}
+
+        local_dir = File.dirname(__FILE__)
+        trimmed = Dir["#{local_dir}/*/"].map { |subdir| subdir.gsub(/\/$/, "") }
+        supported = trimmed.select { |subdir| File.exists?(File.join(subdir, File.basename(subdir)+".rb")) }
+        supported.each { |lang| load_language(lang) }
+        supported.map { |lang| lang.to_sym }
+      end
+
+      def load_language(lang_name)
+        lang_name = File.basename(lang_name.to_s, ".rb").to_sym
+        new_classname = classname_for_filename(lang_name)
+        source_file = path_for_language(lang_name)
+
+        lang = Class.new(Talk::Language) {}
+
+        lang.class_eval( IO.read(source_file), source_file )
+        lang.class_eval( "def path\n\t\"#{File.dirname(source_file)}\"\nend" )
+        lang.class_eval( "def name\n\t\"#{lang_name}\"\nend" )
+        @languages[lang_name.to_sym] = lang
+      end
+
+      def language_named(lang_name)
+        load_supported_languages if @languages.nil?
+        @languages[lang_name.to_sym].new
+      end
+    end
+
+    def initialize
+      @written = {}
+    end
+
+    def render(base, target)
+      @base = base
+      @target = target
+      @output_path = find_output_path
+
+      make_source
+      prune if @target[:prune]
+    end
+
+    def write(path, contents, conditional=true)
+      @written[File.absolute_path(path)] = contents
+      return if conditional and File.exists? path and IO.read(path) == contents
+      
+      FileUtils::mkdir_p(File.dirname(path))
+      File.write(path, contents)
+    end
+
+    def prune
+      # Delete anything we didn't conditionally write, unless it's a directory
+      dirs = []
+      Dir.glob(@output_path+"/**/*").each do |path|
+        abs_path = File.absolute_path(path)
+        unless @written.has_key?(abs_path) then
+          if File.directory?(abs_path) then
+            dirs.push abs_path
+          else
+            FileUtils::rm(abs_path)
+          end
+        end
+      end
+
+      # Now sort the directories by length, so longest directories are first
+      # Since these are abspaths, that should guarantee subdirectories come before parents
+      # Then delete each empty directory, tested by containing no entries other than '.' and '..'
+      dirs.sort! { |a,b| b.length <=> a.length }
+      dirs.each { |dir| FileUtils::rmdir(dir) if (Dir.entries(dir) - %w{ . .. }).empty? }
+    end
+
+    def find_output_path
+      @target[:destination]
+    end
+
+    def generate_template(output_file, template_file=nil)
+      template_file ||= output_file + ".erb"
+      template_contents = IO.read(File.join(self.path, "templates", template_file))
+      erb = ERB.new(template_contents)
+      erb.filename = template_file
+      source = erb.result(binding)
+      filename = File.join(@output_path, output_file)
+      write(filename, source)
+      source
+    end
+
+    def meta(name)
+      return nil if @target[:meta].nil?
+      name = name.to_s
+
+      @target[:meta].each do |meta|
+        return meta[:value] if meta[:name].to_s == name
+      end
+
+      nil
+    end
+
+      def string_overlap(a,b)
+      [a.length, b.length].min.times do |i|
+        if a[i] != b[i] then
+          return "" if i == 0
+          return a[0..i-1]
+        end
+      end
+
+      a.length < b.length ? a : b
+    end
+
+    def wrap_text_to_width(text, width=80, preamble="")
+      width -= preamble.length
+      words = text.split(/\s+/)
+      lines = []
+
+      words.each do |word|
+        if lines.empty? or (lines.last + " " + word).length >= width then
+          lines.push (preamble + word)
+        else
+          lines.last << " " + word
+        end
+      end
+
+      lines.empty? ? "" : lines.join("\n")
+    end
+
+    def common_class_prefix
+      prefix = nil
+      @base[:class].each do |cls|
+        if prefix.nil? then
+          prefix = cls[:name]
+        else
+          prefix = string_overlap(prefix, cls[:name])
+          return nil if prefix.length == 0
+        end
+      end
+
+      prefix
+    end
+
+    def classname_for_filename(name) # /path/to/file_name.rb to FileName
+      File.basename(name.to_s, ".rb").split('_').collect { |word| word.capitalize }.join("")
+    end
+
+    def truncated_name(name)
+      name = name[:name] if name.is_a? Hash
+      name.split('.').last
+    end
+  end
+end

data/lib/languages/objc/objc.rb

@@ -0,0 +1,162 @@
+def make_source
+  @prefix = common_class_prefix if meta(:namespace) == "true"
+  master_files = [ "TalkClasses.h", "TalkClassesForward.h", "TalkConstants.h", "TalkObjectList.h"]
+  master_files.each { |template| generate_template(template) }
+
+  @base[:class].each do |cls|
+    @current_class = cls
+    @current_class[:field] ||= []
+    file_base = filename_for_class(cls)
+    [".h", ".m"].each { |ext| generate_template(file_base+ext, "class"+ext+".erb") }
+  end
+end
+
+def filename_for_class(cls)
+  class_dir = "classes"
+  if meta(:namespace) == "true" then
+    namespace = cls[:name][@prefix.length..-1].split(".")[0..-2]
+    return File.join(class_dir, truncated_name(cls)) if namespace.empty?
+
+    namespace = namespace[1..-1] while namespace[0].length == 0
+    File.join(class_dir, namespace.join("/"), truncated_name(cls))
+  else
+    File.join(class_dir, truncated_name(cls))
+  end
+end
+
+def autogenerated_warning
+  <<-AUTOGEN_DONE
+// Autogenerated from Talk
+// Please do not edit this file directly. Instead, modify the underlying .talk files.
+  AUTOGEN_DONE
+end
+
+def glossary_term_name(name)
+  "k"+name
+end
+
+def constant_definition(constant)
+  "#{constant[:name]} = #{constant[:value].to_i}, #{comment_line(constant)}"
+end
+
+def comment_line(tag)
+  tag[:description].nil? ? "" : "//!< #{tag[:description]}"
+end
+
+def comment_block(tag, indent_level=0)
+  lines = []
+  indent = "\t" * indent_level
+  lines.push(indent + "/*!")
+  lines.push(wrap_text_to_width(tag[:description], 80, indent + " *  ")) unless tag[:description].nil?
+  lines.push(indent + " *  ")
+  lines.push(indent + " *  " + definition_reference(tag))
+  lines.push(indent + " */")
+
+  lines.join("\n")
+end
+
+def definition_reference(tag)
+  "@talkFile #{tag[:__meta][:file]}:#{tag[:__meta][:line]}"
+end
+
+def rootclass
+  @target[:rootclass] || "TalkObject"
+end
+
+def superclass(cls)
+  cls[:inherits] || rootclass
+end
+
+def is_native?(type)
+  type != "talkobject" and is_primitive?(type)
+end
+
+def is_array?(type)
+  type == "[]"
+end
+
+def is_dict?(type)
+  type == "{}"
+end
+
+def mapped_name(container_name, object_name, type, name_key=:name)
+  object_name = object_name[:name] if object_name.is_a? Hash
+  container_name = container_name[:name] if container_name.is_a? Hash
+  container_name = truncated_name(container_name)
+
+  @target[:map].each do |map|
+    matches = (map[:type] == type.to_s && map[:class_name] == container_name && map[:field_name] == object_name)
+    return map[:new_field_name] if matches
+  end
+
+  object_name
+end
+
+def assist_line(field)
+  return nil if field[:type].length <= 1
+  elements = []
+  field[:type].reverse.each do |type|
+    elements.push case
+      when is_array?(type)
+        "array"
+      when is_dict?(type)
+        "dict"
+      when type == "talkobject"
+        "TalkObject"
+      when is_native?(type)
+        "native"
+      else
+        truncated_name(type)
+    end
+  end
+
+  elements.join(".")
+end
+
+def trimmed_fields(cls)
+  return cls[:field] unless truncated_name(cls[:name]) == 'NamedObjectWrapper'
+  cls[:field].reject { |f| f[:name] == "body" }
+end
+
+def dynamic_body_for_named_wrapper
+  return "@dynamic body;" if truncated_name(@current_class[:name]) == 'NamedObjectWrapper'
+  ""
+end
+
+def primitive_type(unsigned, size)
+  type = "int#{size}_t"
+  type = "u" + type if unsigned
+  type
+end
+
+def field_tags(field)
+  case field[:type].last
+  when "real", "bool", "uint8", "uint16", "uint32", "uint64", "int8", "int16", "int32", "int64"
+    "(readwrite,assign)"
+  else
+    "(readwrite,nonatomic,retain)"
+  end
+end
+
+def field_definition(cls, field)
+  base_type = field[:type].last
+  objc_type = case
+    when is_array?(base_type)
+      "NSMutableArray *"
+    when is_dict?(base_type)
+      "NSMutableDictionary *"
+    when (base_type == "talkobject" or base_type == "object")
+      "TalkObject *"
+    when base_type.match(/(u)?int(8|16|32|64)/)
+      primitive_type(not($1.nil?), $2)
+    when base_type == "real"
+      "double"
+    when base_type == "bool"
+      "BOOL"
+    when base_type == "string"
+      "NSString *"
+    else
+      truncated_name(base_type) + " *"
+  end
+  "#{objc_type} #{mapped_name(cls, field, :field)}"
+end