terse_ruby 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86cb4b9b2d13dd5a177f684edd7f151b4e7e24ac
-  data.tar.gz: d255dd24063cb2fa9e7010c6e3024dcb0adb888e
+  metadata.gz: 79aecaa694ade661bca00b2cd64fdf3704212b7f
+  data.tar.gz: 1dff71c71f0a27f982394d3d30cfc6949bd17000
 SHA512:
-  metadata.gz: 0f33d258de944a568cf348257f5c5ba1eba7c5aaaf28c19ec5ef9d550db2ccb5e214972ab805edbecf7a4c51d1d5eb1cc19f1c76cee3f4d1c92095c8903c890a
-  data.tar.gz: b2118518ae4f4d8e151c23a09648319111ca2003eeeceb00bd32f35cea44be2baec012229a6314d920d8dcdff8c6bcf05ae1467964044004d0cba6af6a3a8a35
+  metadata.gz: 0e8abe0b27382b2aac3a15aba0a12c6c901e9c78b2c7dea75d80888e7066417ec763f3459261a8d04ee4194ea78b3306d86db62d07bed40c4fadfd83ef1d6da4
+  data.tar.gz: 064b6152d319c606beaad32edeaa616e9a6a561f331c7ca104a968963fb3811b2ab2ff5cb78cce68f5fa33097866fba1995ac045c201c06bbb94108a4dac7d85

data/README.txt

@@ -18,7 +18,7 @@
 # end  
 #
 #
-# Rules :
+# Keywords :
 # Terse Ruby will look through the supplied files and convert certain keywords at the start of lines :
 # c -> class
 # m -> module
@@ -49,7 +49,59 @@
 #
 # Alternatively, the below two lines are all you need to run terse_ruby within your own Ruby file :
 #
-# require_relative "../lib/terse_ruby"
+# require "terse_ruby"
+# 
+# # (optionally add to ARGV here)
 # TerseRuby.scan_files ARGV
 #
-# (if ARGV have not been supplied, you'll need to construct this object yourself first)
+# If ARGV have not been supplied, you'll need to add your args to ARGV, e.g. ARGV << "-v"; ARGV << "terse_file.txt"
+# Note that ARGV is not any ordinary array; terse_ruby uses the 'argv' gem which adds methods to the ARGV object;
+# therefore we must supply the ARGV object to TerseRuby.scan_files
+
+
+# Terse Java
+#
+# Invoke in the same way as TerseRuby, but instead using the module name TerseJava; e.g.
+# ruby -e "require 'terse_ruby'; TerseRuby.scan_files ARGV" [one or more files] [flags]
+#   or
+# TerseJava.scan_files ARGV
+#
+# Keywords :
+# 
+# imp -> import
+# pk -> package
+# c -> class
+# impl -> implements
+# ex -> extends
+# int -> interface
+# ab -> abstract
+# e -> enum
+# st -> static
+# v -> void
+# m -> main
+# p -> public
+# pt -> protected
+# pv -> private
+# r -> return
+# s -> String
+# i -> Integer
+# b -> Boolean
+# f -> Float
+# fn -> final
+# 
+# 
+# Flags :
+#
+# The same flags may be used as with Terse Ruby
+#
+# Notes :
+#
+# Constructors will not be made, as it is impossble to 100% accurately distinguish between a variable and a method in terse form.
+# Getters and setters will not be made, as it is impossble to 100% accurately distinguish between a variable and a method in terse form.
+# This is acceptable, as most IDEs are able to generate constructors and getters-and-setters.
+# 
+# Primitive types (int, float, etc.) will never be used; i -> Integer, f -> Float, etc.
+# 
+# Obvious class-beginnings will be given { (and } at the end of the file); obvious method endings (i.e. the 'return' keyword) will be given }
+# Because in terse form, there is ambiguity between methods and variables, some method starts will not gain { and some regular code lines will not gain ;
+# You should expect Java expanded from terse-form to contain compilation errors of this kind.

data/build.rb

@@ -0,0 +1,50 @@
+# Simple build script
+# Deletes the existing gem file (if present)
+# Uninstalls the gem
+# Builds the gem
+# Installs the new gem
+
+# Note : when calling system (or backticks, etc.) th enew process starts at the system default, not the current working directory.
+# Therefore we need to use a syntax of : system "cd #{gem_dir} && #{i_cmd}"
+
+# Run from this directory!
+gem_dir = Dir.getwd
+
+# Delete existing .gem files in the dir
+
+gemfiles = Dir.entries(gem_dir).collect {|q| q if q =~ /.gem$/}.compact
+
+gemfiles.each do |q| 
+	File.delete q
+	puts "Deleted #{q}"
+end
+
+gemfiles = Dir.entries(gem_dir).collect {|q| q if q =~ /.gem$/}.compact
+raise "Gem has not been deleted" unless gemfiles.size == 0
+
+# Uninstall, build, install
+gemspecs = Dir.entries(gem_dir).collect {|q| q if q =~ /.gemspec$/}.compact
+
+raise "Did not find a .gemspec in #{gem_dir}" if gemspecs.size < 1
+raise "Found more than one .gemspec in #{gem_dir}" if gemspecs.size > 1
+
+gemspec = gemspecs[0]
+
+gemname = File.basename(gemspec, File.extname(gemspec))
+
+u_cmd = "gem uninstall #{gemname}"
+system u_cmd
+
+b_cmd = "gem build #{gemspec}"
+system "cd #{gem_dir} && #{b_cmd}"
+
+gemfiles = Dir.entries(gem_dir).collect {|q| q if q =~ /.gem$/}.compact
+raise "Gem was not built" unless gemfiles.size == 1
+
+gemfile = gemfiles[0]
+raise "Gem file is not for the expected gem, expected a #{gemname} gem but found #{gemfile}" unless gemfile =~ /^#{gemname}/
+
+i_cmd = "gem install #{gemfile}"
+system "cd #{gem_dir} && #{i_cmd}"
+
+puts "Gem #{gemname} built & installed"

data/lib/{terse_ruby → terse}/format.rb

@@ -1,38 +1,39 @@
-module TerseRuby
+module Terse
 
     # Simple class for formatting the list of lines
     class Format
 
         # Apply indentation
         # It is easier to do this once the full list of newlines is assembled
-        def self.indent lines
+        def self.indent lines, settings
             indented_lines = []
             indent_level = 0
-            keys = %w{ class module def if when case for }
-            first_word_regex = /^([a-zA-Z0-9_]+)(\s+|$)/ 
             lines.each do |l|
                 l.strip!
-                l =~ first_word_regex # set the $ variables for inspection
-                # check for "end" before indenting
-                indent_level -= 1 if $1 == "end" 
-                
+                l =~ settings.indent_out_regex
+
+                # check for a loop-ending before indenting           
+                indent_level -= 1 if settings.indent_out.include?($1.to_s.strip) # must to_s in case $1 is nil
                 indent_level.times do
                     l.insert(0, "\t")
                 end
-                indented_lines << l        
-                # puts indented_lines
+                indented_lines << l.dup # need to call .dup ; it will otherwise mess up indentation of loop-ending lines
                 
                 # check for indent-increasing keywords after indenting
-                indent_level += 1 if keys.include?($1)
+                l =~ settings.indent_in_regex
+                indent_level += 1 if settings.indent_in.include?($1.to_s.strip) # must to_s in case $1 is nil
             end
             indented_lines
         end
 
         # Insert empty lines in between the end of a method and the start of the next (same for classes & modules) 
-        def self.space_lines lines
+        def self.space_lines lines, keywords, settings
             spaced_lines = []
             
-            keys = %w{ class module def }
+            # Filter out keywords that do not trigger some sort of indent-change
+            keys = keywords.dup
+            keys = keys.delete_if {|k| !(k.needs_top_level_end || k.needs_inner_end)}
+            keys.collect! {|k| k.substitute}
             first_word_regex = /^\s*([a-zA-Z0-9_]+)(\s+|$)/
             for i in 0 ... lines.size - 1 
                 first_line = lines[i]
@@ -42,9 +43,9 @@ module TerseRuby
                 
                 first_line =~ first_word_regex # set the $ variables for inspection
                 # We only care about line-pairs where the first line is an end, and the next one matches one of our keys
-                if $1 == "end"
+                if $1.to_s.strip == settings.loop_ending.strip    
                     next_line =~ first_word_regex
-                    spaced_lines << "" if keys.include?($1)
+                    spaced_lines << "" if keys.include?($1.to_s.strip)
                 end 
             end
             # Remember to add the last line!

data/lib/terse/keyword.rb

@@ -0,0 +1,166 @@
+module Terse
+
+    # A class storing all information about a keyword & what it should be transformed into 
+    class Keyword
+        attr_accessor :keyword
+        attr_accessor :substitute
+        attr_accessor :regex
+        attr_accessor :follow_on_regex
+        attr_accessor :follow_on_substitute
+        attr_accessor :try_follow_on_regex
+        attr_accessor :needs_top_level_start
+        attr_accessor :needs_inner_start
+        attr_accessor :needs_top_level_end
+        attr_accessor :needs_inner_end
+        attr_accessor :is_end
+
+        # some keywords naturally imply that the line should have a line-ending, e.g. ; for Java 
+        # line-endings should not be applied if the keyword indicates the start/end of a class/method/block, etc.
+        # Internally, :needs_top_level_end and :needs_inner_end take priority over :needs_line_ending
+        attr_accessor :needs_line_ending 
+
+        def initialize(keyword)
+            @keyword = keyword
+            @regex = gen_regex_from_keyword keyword
+            @follow_on_regex = gen_regex_from_keyword_including_follow_on keyword
+        end
+        
+        # # TODO this doesn't work, needs to process the thing following the keyword, not the keyword itself
+        # def set_substitute
+        #     case @keyword
+        #         when "a", "r", "w"
+        #             @substitute = ":" + @substitute
+        #         when "req", "reqr"
+        #             @substitute = "\"" + @substitute + "\"" unless ["\"", "'"].include? @substitute[0]
+        #     end
+        # end
+        
+        
+        
+        # # @substitutes = %W{ require require_relative include class method def end attr_accesor attr_reader attr_writer }
+
+            
+        # # def generate_regexes
+        # #     r = []
+        # #     for i in 0 ... @keywords.size
+        # #         r << Keyword.new(@keywords[i], @substitutes[i], gen_regex_from_keyword(@keywords[i]))
+        # #     end
+        # #     r
+        # # end
+
+        # # Simple regex to match a keyword at the start of a line
+        # def gen_regex_from_keyword keyword
+        #     return /(^\s*)(#{keyword})(\s+|$)/
+        # end
+        
+        # # Regex to match a keyword at the start of a line, and the next word on that line
+        # # E.g. this will also catch (in $3) the item following the "require" keyword
+        # # This enables the routine to format this follow-on word, e.g. to turn 'req a_gem' into
+        # # 'require "a_gem"'
+        # def gen_regex_from_keyword_including_follow_on keyword
+        #     return /(^\s*)(#{keyword})\s+([a-zA-Z0-9_]+)/
+        # end
+        
+        # def self.generate_ruby_keywords
+        #     keywords = []
+        #     keys = [:req, :reqr, :i, :c, :m, :d, :e, :a, :r, :w]
+        #     keys.each do |key|
+        #         k = Keyword.new key
+        #         # k.keyword = key
+        #         case key
+        #             when :req
+        #                 k.substitute = "require"
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "\"\#{$3}\""
+        #             when :reqr
+        #                 k.substitute = "require_relative"
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "\"\#{$3}\""
+        #             when :i
+        #                 k.substitute = "include"
+        #             when :c
+        #                 k.substitute = "class"
+        #                 k.needs_top_level_end = true
+        #             when :m
+        #                 k.substitute = "module"
+        #                 k.needs_top_level_end = true
+        #             when :d
+        #                 k.substitute = "def"
+        #                 k.needs_inner_end = true
+        #             when :e
+        #                 k.substitute = "end"
+        #                 k.is_end = true
+        #             when :a
+        #                 k.substitute = "attr_accessor"                    
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "$3.to_sym"#"\":\#{$3}\""
+        #             when :r
+        #                 k.substitute = "attr_reader"              
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "$3.to_sym"
+        #             when :w
+        #                 k.substitute = "attr_writer"              
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "$3.to_sym"
+                    
+        #         else
+        #             # raise "Unknown keyword #{key}"
+        #             puts "Unknown keyword #{key}"
+        #         end
+        #         keywords << k
+        #     end # end keys.each
+        #     keywords
+        # end
+
+        # def self.generate_java_keywords
+        #     keywords = []
+        #     keys = [:imp, :c, :ex, :inc, :ab, :e, :st, :v, :m, :p, :pt, :pv, :r, :s, :i, :b, :f, :fn]
+        #     keys.each do |key|
+        #         k = Keyword.new key
+        #         # k.keyword = key
+        #         case key
+        #             when :imp
+        #                 k.substitute = "import"
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "\"\#{$3}\""
+        #             when :reqr
+        #                 k.substitute = "require_relative"
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "\"\#{$3}\""
+        #             when :i
+        #                 k.substitute = "include"
+        #             when :c
+        #                 k.substitute = "class"
+        #                 k.needs_top_level_end = true
+        #             when :m
+        #                 k.substitute = "module"
+        #                 k.needs_top_level_end = true
+        #             when :d
+        #                 k.substitute = "def"
+        #                 k.needs_inner_end = true
+        #             when :e
+        #                 k.substitute = "end"
+        #                 k.is_end = true
+        #             when :a
+        #                 k.substitute = "attr_accessor"                    
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "$3.to_sym"#"\":\#{$3}\""
+        #             when :r
+        #                 k.substitute = "attr_reader"              
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "$3.to_sym"
+        #             when :w
+        #                 k.substitute = "attr_writer"              
+        #                 k.try_follow_on_regex = true
+        #                 k.follow_on_substitute = "$3.to_sym"
+                    
+        #         else
+        #             # raise "Unknown keyword #{key}"
+        #             puts "Unknown keyword #{key}"
+        #         end
+        #         keywords << k
+        #     end # end keys.each
+        #     keywords
+        # end
+    end
+end

data/lib/terse/keyword_java.rb

@@ -0,0 +1,103 @@
+require_relative "keyword"
+
+module Terse
+
+    # A class storing all information about a keyword & what it should be transformed into 
+    class KeywordJava < Keyword
+
+        def initialize(keyword)
+            super(keyword)
+            @loop_ending = "}"
+            @line_ending = ";"
+        end
+
+        # Simple regex to match a keyword
+        def gen_regex_from_keyword keyword
+            # return /(^|\s+)(#{keyword})(\s+|$)/
+            return /(^|\s+|\w*\()(#{keyword})(\s+|$)/
+        end
+        
+        # Regex to match a keyword at the start of a line, and the next word on that line
+        # E.g. this will also catch (in $3) the item following the "require" keyword
+        # This enables the routine to format this follow-on word, e.g. to turn 'req a_gem' into
+        # 'require "a_gem"'
+        def gen_regex_from_keyword_including_follow_on keyword
+            return /(^|\s+)(#{keyword})\s+([a-zA-Z0-9_]+)/
+        end
+        
+        def self.generate_keywords
+            keywords = []
+            keys = [:imp, :pk, :c, :ex, :impl, :int, :ab, :e, :st, :v, :m, :p, :pt, :pv, :r, :s, :i, :b, :f, :fn]
+            keys.each do |key|
+                k = KeywordJava.new key
+                # k.keyword = key
+                case key
+                when :imp
+                    k.substitute = "import"
+                    k.needs_line_ending = true
+                when :pk
+                    k.substitute = "package"
+                    k.needs_line_ending = true
+                when :c
+                    k.substitute = "class"
+                    k.needs_top_level_start = true
+                    k.needs_top_level_end = true
+                when :ex
+                    k.substitute = "extends"
+                when :impl
+                    k.substitute = "implements"
+                when :int
+                    k.substitute = "interface"
+                when :ab
+                    k.substitute = "abstract"
+                when :e
+                    k.substitute = "enum"
+                    k.needs_top_level_start = true
+                    k.needs_top_level_end = true
+                when :st
+                    k.substitute = "static"
+                    k.needs_line_ending = true
+                when :v
+                    k.substitute = "void"
+                    k.needs_inner_start = true
+                    k.needs_inner_end = true
+                when :m
+                    k.substitute = "main"
+                when :p
+                    k.substitute = "public"
+                    k.needs_line_ending = true
+                when :pt
+                    k.substitute = "protected"
+                    k.needs_line_ending = true
+                when :pv
+                    k.substitute = "private"
+                    k.needs_line_ending = true
+                when :r
+                    k.substitute = "return"
+                    k.needs_inner_end = true
+                    k.needs_line_ending = true
+                when :s
+                    k.substitute = "String"
+                    k.needs_line_ending = true
+                when :i
+                    k.substitute = "Integer"
+                    k.needs_line_ending = true
+                when :b
+                    k.substitute = "Boolean"
+                    k.needs_line_ending = true
+                when :f
+                    k.substitute = "Float"
+                    k.needs_line_ending = true
+                when :fn
+                    k.substitute = "final"
+                    k.needs_line_ending = true
+                else
+                    # raise "Unknown keyword #{key}"
+                    puts "Unknown keyword #{key}"
+                end
+                keywords << k
+            end # end keys.each
+            keywords
+        end
+    end
+end