guff 0.0.2

data/Manifest.txt

@@ -0,0 +1,21 @@
+Rakefile
+README.txt
+CHANGELOG.txt
+Manifest.txt
+setup.rb
+lib/guff/version.rb
+lib/guff/java_source.rb
+lib/guff.rb
+test/test_helper.rb
+test/java_source/files/ClassWithAnnotatedFields.java
+test/java_source/files/ClassWithAnnotatedMethods.java
+test/java_source/files/ClassWithFields.java
+test/java_source/files/ClassWithMethods.java
+test/java_source/files/EmptyClass.java
+test/java_source/files/GenericClass.java
+test/java_source/annotation_declaration_test.rb
+test/java_source/class_declaration_test.rb
+test/java_source/field_declaration_test.rb
+test/java_source/method_declaration_test.rb
+test/java_source/test_helper.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,3 @@
+README for guff
+===============
+

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'guff', 'version')
+
+AUTHOR = "Mike Hogan"  # can also be an array of Authors
+EMAIL = "me@mikehogan.net"
+DESCRIPTION = "An API to describe and generate Java source code. The idea is to avoid writing all the 'guff' that is typical in java projects by generating it from more succinct ruby models."
+GEM_NAME = "guff" # what ppl will type to install your gem
+RUBYFORGE_PROJECT = "guff" # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+
+
+NAME = "guff"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (Guff::VERSION::STRING + (REV ? ".#{REV}" : ""))
+                          CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "guff documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/*_test.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  #p.changes        - A description of the release's latest changes.
+  #p.extra_deps     - An array of rubygem dependencies.
+  #p.spec_extras    - A hash of extra values to set in the gemspec.
+end

data/lib/guff/java_source.rb

@@ -0,0 +1,576 @@
+require 'fileutils'
+
+module ArgumentsHelper
+    def ensure_array(a)
+        if (a.respond_to? :[])
+            return a
+        end
+        [a]
+    end
+end
+
+class String
+    def ends_with?(s)
+        reverse.index(s) == 0
+    end
+end
+
+class Array
+    def each_joined(joiner)
+        last = size - 1
+        for i in 0..last
+            joiner.call if i > 0
+            yield self[i]
+        end
+    end
+end
+
+module Guff
+    module JavaSource
+
+        module ClientSyntaxSupport
+            def annotation(type)
+                a = Annotation.new(type)
+                yield a if block_given?
+                a
+            end
+        end
+
+        module AnnotationSupport
+            def add_annotation(type,value=nil)
+                annotation = Annotation.new(type,value)
+                @annotations << annotation
+                yield annotation if block_given?
+                self
+            end
+
+            def write_annotations_to(writer)
+                @annotations.each {|a|
+                    a.write_to(writer)
+                    writer.new_line
+                }
+            end
+        end
+
+        module ParameterSupport
+            def takes(name, type)
+                @parameters << Parameter.new(name, type)
+                self
+            end
+        end
+
+        module ScopeSupport
+            def package_local
+                @scope = ''
+                self
+            end
+
+            def protected
+                @scope = 'protected'
+                self
+            end
+
+            def public
+                @scope = 'public'
+                self
+            end
+
+            def private
+                @scope = 'private'
+                self
+            end
+        end
+
+        module ModifierSupport
+            def static
+                @modifiers << 'static'
+                self
+            end
+
+            def final
+                @modifiers << 'final'
+                self
+            end
+
+            def abstract
+                @modifiers << 'abstract'
+                self
+            end
+        end
+
+        class UnnamedProperty
+            def initialize(value)
+                @value = value
+            end
+
+            def write_to(writer)
+                write_value(writer)
+            end
+
+            def write_value(writer)
+                @value.write_to(writer) if @value.respond_to? :write_to
+                writer.append(@value) unless @value.respond_to? :write_to
+                self
+            end
+        end
+
+        class Property < UnnamedProperty
+            def initialize(name, value)
+                super(value)
+                @name = name
+            end
+
+            def write_to(writer)
+                writer.append(@name).append("=")
+                write_value(writer)
+            end
+        end
+
+        class Annotation
+            def initialize(type,value=nil)
+                @type = type
+                @properties = []
+                @properties << UnnamedProperty.new(value) unless value.nil?
+            end
+
+            def write_to(writer)
+                writer.append("@#{@type}")
+                write_properties_to(writer) unless @properties.empty?
+            end
+
+            def write_properties_to(writer)
+                writer.append("(").indent.new_line
+                joiner = proc {
+                    writer.append(",").new_line
+                }
+                writer.append_all(@properties, joiner)
+                writer.outdent.new_line.append(")")
+            end
+
+            def add_property(name, value)
+                @properties << Property.new(name, value)
+                self
+            end
+        end
+
+        class Parameter
+            def initialize(n, t)
+                @name=n
+                @guff_type=t
+            end
+
+            def as_source
+                "#{guff_type} #{@name}"
+            end
+
+            def name
+                @name
+            end
+
+            def guff_type
+                @guff_type
+            end
+        end
+
+        class Constructor
+            include ArgumentsHelper, ParameterSupport, AnnotationSupport
+
+            def initialize(name)
+                @name = name
+                @parameters = []
+                @body = Body.default_body
+                @annotations = []
+            end
+
+            def body
+                @body = Body.new
+                yield @body
+                self
+            end
+
+            def parameters
+                result = []
+                @parameters.each {|p|
+                    result << p.as_source
+                }
+                result.join(',')
+            end
+
+            def write_to(writer)
+                writer.ensure_member_separation_line
+                write_annotations_to(writer)
+                write_declaration(writer)
+                @body.write_to(writer) unless @body.nil?
+            end
+
+            def write_declaration(writer)
+                writer.append("public #{@name}(" ).append(parameters).append(")")
+            end
+        end
+
+        module BodyBits
+            class Line
+                def initialize(l)
+                    @line = l
+                end
+
+                def write_to(writer)
+                    writer.line(@line)
+                end
+            end
+
+            class Text
+                def initialize(t)
+                    @text = t
+                end
+
+                def write_to(writer)
+                    writer.append(@text)
+                end
+            end
+
+            class NestedBody
+                def initialize(body)
+                    @body = body
+                end
+
+                def write_to(writer)
+                    @body.write_to(writer)
+                end
+            end
+        end
+
+        class Body
+            def self.default_body
+                EmptyBody.new
+            end
+
+            def initialize
+                @bits = []
+            end
+
+            def line(l)
+                @bits << BodyBits::Line.new(l)
+                self
+            end
+
+            def append(t)
+                @bits << BodyBits::Text.new(t)
+                self
+            end
+
+            def body
+                nested = Body.new
+                @bits << BodyBits::NestedBody.new(nested)
+                yield nested
+                self
+            end
+
+            def write_to(writer)
+                writer.open_brace
+                @bits.each {|bit|
+                    bit.write_to(writer)
+                }
+                writer.close_brace
+            end
+        end
+
+        class EmptyBody < Body
+            def write_to(writer)
+                writer.semi_colon.new_line
+            end
+        end
+
+        class Method < Constructor
+            include ScopeSupport, ModifierSupport, AnnotationSupport
+
+            def initialize(name)
+                super(name)
+                @return_type = 'void'
+                @modifiers = []
+                @scope = 'public'
+            end
+
+            def returns(t)
+                @return_type = t
+                self
+            end
+
+            def returns_list_of(t)
+                @return_type= "List<#{t}>"
+                self
+            end
+
+            def return_type
+                @return_type
+            end
+
+            def write_declaration(writer)
+                writer.word(@scope).words(@modifiers).word(@return_type).word("#{@name}(").append(parameters).append(")")
+            end
+        end
+
+        class Field
+            include ScopeSupport, ModifierSupport, AnnotationSupport
+            def initialize(name, type)
+                @name = name
+                @type = type
+                @scope = 'private'
+                @modifiers = []
+                @initializer = ''
+                @annotations = []
+            end
+
+            def write_to(writer)
+                write_annotations_to(writer)
+                writer.word(@scope).words(@modifiers).word(@type).word(@name).word(@initializer).semi_colon.new_line
+            end
+
+            def initial(i)
+                @initializer = "= #{i}"
+                self
+            end
+        end
+
+        class Class
+            include ScopeSupport, ModifierSupport, AnnotationSupport
+
+            def initialize(name, package, source_file)
+                @name = name;
+                @package = package
+                @modifiers = ['public']
+                @extends = nil
+                @instance_methods = []
+                @fields = []
+                @constructors = []
+                @source_file=source_file
+                @genericized_using = ''
+                @interfaces = nil
+                @annotations = []
+                @implements = nil
+            end
+
+            def add_field(name, type)
+                f = Field.new(name, type)
+                @fields << f
+                f
+            end
+
+            def genericized_using(g)
+                @genericized_using = g
+                self
+            end
+
+            def name
+                @name
+            end
+
+            def fully_qualified_name
+                "#{@package}.#{@name}"
+            end
+
+            def extends(d)
+                @extends = d
+                self
+            end
+
+            def implements(*interfaces)
+                @implements = interfaces
+                self
+            end
+
+            def add_method(name)
+                result = Method.new(name)
+                @instance_methods << result
+                result
+            end
+
+            def add_constructor
+                result = Constructor.new(@name)
+                @constructors << result
+                result
+            end
+
+            def write_to(writer)
+                write_annotations_to(writer)
+                writer.words(@modifiers).word("class").word(@name).append(@genericized_using).word_with_prefix('extends', @extends).list_with_prefix('implements', @implements).open_brace
+
+                @fields.each {|f|
+                    f.write_to(writer)
+                }
+                @constructors.each {|c|
+                    c.write_to(writer)
+                }
+                @instance_methods.each {|m|
+                    m.write_to(writer)
+                }
+                writer.close_brace
+            end
+        end
+
+        class SourceFile
+            def initialize
+                @package = 'set the package'
+                @classes = []
+            end
+
+            def save_in(root)
+                writer = Printer.new
+                write_to(writer)
+                directory = root << "/" + package_as_directory
+                if (!FileTest.exist?(directory))
+                    FileUtils.mkdir_p(directory)
+                end
+                filename =  directory << "/" << @name << ".java"
+                file = File.new(filename, "w")
+                file.write(writer.contents)
+                file.close
+                filename
+            end
+
+            def package_as_directory
+                @package.split('.').join('/')
+            end
+
+            def package(p)
+                @package=p
+                self
+            end
+
+            def begin_class(name)
+                @name = name
+                result = Class.new(name, @package, self)
+                @classes << result
+                yield result if block_given?
+                self
+            end
+
+            def write_to(writer)
+                writer.line(package_def).line
+                @classes.each {|c|
+                    c.write_to(writer)
+                }
+                writer
+            end
+
+            def package_def
+                "package #{@package};"
+            end
+        end
+
+        class Printer
+            def initialize
+                @text=""
+                @indent=0
+                @current_line = nil
+            end
+
+            def line(s="")
+                append(s)
+                new_line
+            end
+
+            def append(s)
+                if (@current_line.nil?)
+                    @current_line = indent_text
+                end
+                @current_line << s.to_s
+                self
+            end
+
+            def append_all(writers, joiner)
+                writers.each_joined(joiner) {|w|
+                    w.write_to(self)
+                }
+            end
+
+            def word_with_prefix(prefix, w)
+                if (w.to_s.size>0)
+                    word(prefix).word(w)
+                end
+                self
+            end
+
+            def words_with_prefix(prefix, ww)
+                if (ww.nil? == false && ww.size > 0)
+                    word(prefix).words(ww)
+                end
+                self
+            end
+
+            def list_with_prefix(prefix, list, joiner=',')
+                if (list.nil? == false && list.size > 0)
+                    word(prefix).word(list.join(joiner))
+                end
+                self
+            end
+
+            def ensure_member_separation_line
+                if (!@text.ends_with?("\n\n"))
+                    new_line
+                end
+            end
+
+            def word(w)
+                if (w.to_s.size > 0)
+                    if (!@current_line.nil? && !@text.ends_with?(' '))
+                        w = " #{w}"
+                    end
+                    append(w)
+                end
+                self
+            end
+
+            def words(ww)
+                ww.each {|w|
+                    word(w)
+                }
+                self
+            end
+
+            def semi_colon
+                append(';')
+            end
+
+            def indent_text
+                result = ""
+                @indent.times {
+                    result << "    "
+                }
+                result
+            end
+
+
+            def new_line
+                @text << @current_line unless @current_line.nil?
+                @text << "\n"
+                @current_line=nil
+                self
+            end
+
+            def indent
+                @indent += 1
+                self
+            end
+
+            def outdent
+                @indent -= 1
+                self
+            end
+
+            def open_brace
+                line("{")
+                indent
+            end
+
+            def close_brace
+                outdent
+                line("}")
+            end
+
+            def contents
+                @text
+            end
+        end
+    end
+end

data/lib/guff/version.rb

@@ -0,0 +1,9 @@
+module Guff #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/guff.rb

@@ -0,0 +1,2 @@
+require 'fileutils'
+require 'guff/java_source'