terse_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 86cb4b9b2d13dd5a177f684edd7f151b4e7e24ac
+  data.tar.gz: d255dd24063cb2fa9e7010c6e3024dcb0adb888e
+SHA512:
+  metadata.gz: 0f33d258de944a568cf348257f5c5ba1eba7c5aaaf28c19ec5ef9d550db2ccb5e214972ab805edbecf7a4c51d1d5eb1cc19f1c76cee3f4d1c92095c8903c890a
+  data.tar.gz: b2118518ae4f4d8e151c23a09648319111ca2003eeeceb00bd32f35cea44be2baec012229a6314d920d8dcdff8c6bcf05ae1467964044004d0cba6af6a3a8a35

data/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Richard Morrisby
+
+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.

data/README.txt

@@ -0,0 +1,55 @@
+# Terse Ruby
+# A simple utility to allow you to write shorthand for Ruby classes; the utility will then convert this shorthand file into a genuine Ruby .rb file (either writing a new file or overwriting)
+#
+# E.g. terse_file.txt contains :
+#
+# req a_gem
+# c AClass
+#     i AnInclude
+#     d method1
+#
+# Then Terse Ruby will write a new file terse_file.rb containing :
+#
+# require "a_gem"
+# class AClass
+#     include AnInclude
+#     def method1
+#     end
+# end  
+#
+#
+# Rules :
+# Terse Ruby will look through the supplied files and convert certain keywords at the start of lines :
+# c -> class
+# m -> module
+# r -> require (and will wrap the required item in " " if needed)
+# i -> include
+# d -> def
+# e -> end (method, class & module ends will be added if a subsequent method, class or module is detected, or is end-of-file)
+# a -> attr_accessor (and prefixes the variable name with : to make it a symbol)
+# r -> attr_reader (and prefixes the variable name with : to make it a symbol)
+# w -> attr_writer (and prefixes the variable name with : to make it a symbol)
+#
+# All remaining text in the line is not altered, even if a matching keyword is present, because the keywords need to be at the beginning of the line (ignoring leading whitespace)
+#
+#
+# Flags :
+# v : verbose mode
+# o : overwrite - if the new file already exists, the existing file will be overwritten  
+#
+#
+# Invokation :
+# terse_ruby can be directly invoked from the command-line with :
+#
+# ruby -e "require 'terse_ruby'; TerseRuby.scan_files ARGV" [one or more files] [flags]
+#
+# e.g.
+#
+# ruby -e "require 'terse_ruby'; TerseRuby.scan_files ARGV" terse_file1.txt terse_file2.txt -o -v
+#
+# Alternatively, the below two lines are all you need to run terse_ruby within your own Ruby file :
+#
+# require_relative "../lib/terse_ruby"
+# TerseRuby.scan_files ARGV
+#
+# (if ARGV have not been supplied, you'll need to construct this object yourself first)

data/bin/terse_ruby.rb

@@ -0,0 +1,59 @@
+# Terse Ruby
+# A simple utility to allow you to write shorthand for Ruby classes; the utility will then convert this shorthand file into a genuine Ruby .rb file (either writing a new file or overwriting)
+#
+# E.g. terse_file.txt contains :
+#
+# req a_gem
+# c AClass
+#     i AnInclude
+#     d method1
+#
+# Then Terse Ruby will write a new file terse_file.rb containing :
+#
+# require "a_gem"
+# class AClass
+#     include AnInclude
+#     def method1
+#     end
+# end  
+#
+#
+# Rules :
+# Terse Ruby will look through the supplied files and convert certain keywords at the start of lines :
+# c -> class
+# m -> module
+# r -> require (and will wrap the required item in " " if needed)
+# i -> include
+# d -> def
+# e -> end (method, class & module ends will be added if a subsequent method, class or module is detected, or is end-of-file)
+# a -> attr_accessor (and prefixes the variable name with : to make it a symbol)
+# r -> attr_reader (and prefixes the variable name with : to make it a symbol)
+# w -> attr_writer (and prefixes the variable name with : to make it a symbol)
+#
+# All remaining text in the line is not altered, even if a matching keyword is present, because the keywords need to be at the beginning of the line (ignoring leading whitespace)
+#
+#
+# Flags :
+# v : verbose mode
+# o : overwrite - if the new file already exists, the existing file will be overwritten  
+#
+#
+# Invokation :
+# terse_ruby can be directly invoked from the command-line with :
+#
+# ruby -e "require 'terse_ruby'; TerseRuby.scan_files ARGV" [one or more files] [flags]
+#
+# e.g.
+#
+# ruby -e "require 'terse_ruby'; TerseRuby.scan_files ARGV" terse_file1.txt terse_file2.txt -o -v
+#
+# Alternatively, the below two lines are all you need to run terse_ruby within your own Ruby file :
+#
+# require_relative "../lib/terse_ruby"
+# TerseRuby.scan_files ARGV
+#
+# (if ARGV have not been supplied, you'll need to construct this object yourself first)
+
+
+require_relative "../lib/terse_ruby"
+TerseRuby.scan_files ARGV

data/lib/terse_ruby/format.rb

@@ -0,0 +1,55 @@
+module TerseRuby
+
+    # 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
+            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" 
+                
+                indent_level.times do
+                    l.insert(0, "\t")
+                end
+                indented_lines << l        
+                # puts indented_lines
+                
+                # check for indent-increasing keywords after indenting
+                indent_level += 1 if keys.include?($1)
+            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
+            spaced_lines = []
+            
+            keys = %w{ class module def }
+            first_word_regex = /^\s*([a-zA-Z0-9_]+)(\s+|$)/
+            for i in 0 ... lines.size - 1 
+                first_line = lines[i]
+                next_line = lines[i + 1]
+                
+                spaced_lines << first_line
+                
+                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"
+                    next_line =~ first_word_regex
+                    spaced_lines << "" if keys.include?($1)
+                end 
+            end
+            # Remember to add the last line!
+            spaced_lines << lines[-1]    
+            spaced_lines
+        end
+    end
+end

data/lib/terse_ruby/keyword.rb

@@ -0,0 +1,108 @@
+module TerseRuby
+
+    # 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_end
+        attr_accessor :needs_inner_end
+        attr_accessor :is_end
+
+        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_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
+    end
+end

data/lib/terse_ruby/scan.rb

@@ -0,0 +1,147 @@
+require "more_ruby"
+require_relative "keyword"
+require_relative "format"
+
+module TerseRuby
+
+    # This Scan class does the meat of the work
+    # TODO generate to_s, ==, initialize
+    class Scan
+
+        # The main method. ARGV from the invokation are passed in to here
+        def self.scan_files(argv)
+            puts "\nTerse Ruby called"
+
+            keywords = TerseRuby::Keyword.generate_keywords
+            flags = argv.options
+            @verbose = flags.include_any?("v", "verbose")
+            @overwrite = flags.include_any?("o", "overwrite", "w", "write")
+            @no_formatting = flags.include_any?("n", "noformatting")
+
+            files = argv.values
+
+            if files.size < 1
+                puts "No files supplied"
+            else
+                files.each do |f|
+                    is_file? f
+                end
+                pv "Will scan #{files.size} file#{plural_or_not files}"
+                files.each do |f|
+                    is_file? f
+                    filename = File.basename f
+                    new_filename = gen_new_filename f
+                    newlines = []
+                    lines = File.readlines f
+                    pv "File #{filename} has #{lines.size} line#{plural_or_not lines}"
+                    # If we detect the start of a new class/method/etc. before the last one has been closed
+                    # then insert an "end" to close it off
+                    needs_top_level_end = false
+                    needs_inner_end = false
+                    insert_end = false
+                    lines.each do |l|
+                        line = l.chomp
+                        newline = line # keep the orginial line unless we detect a match 
+                        keywords.each do |k|
+                            if line =~ k.regex
+                                pv "\nMatch found against line --> #{line}"            
+                                pv "Matched -------------------> " + $2
+                                if k.is_end
+                                    if needs_inner_end
+                                        needs_inner_end = false
+                                    elsif needs_top_level_end
+                                        needs_top_level_end = false
+                                    end
+                                    insert_end = false
+                                end
+                                
+                                if k.needs_inner_end
+                                    if needs_inner_end
+                                        newlines << "end"
+                                        # keep needs_inner_end true as we need to watch for an end for this new match
+                                    else
+                                        needs_inner_end = true # set in readiness for the next match
+                                    end
+                                end
+                                
+                                if k.needs_top_level_end
+                                    if needs_inner_end
+                                        newlines << "end"
+                                        needs_inner_end = false
+                                    end
+                                    if needs_top_level_end
+                                        newlines << "end"
+                                        # keep needs_top_level_end true as we need to watch for an end for this new match
+                                    else
+                                        needs_top_level_end = true # set in readiness for the next match
+                                    end
+                                end
+                                
+                                if k.try_follow_on_regex && line =~ k.follow_on_regex
+                                    # puts ""
+                                    # $& is the entire match, not just the bits in ( )
+                                    remainder = line[$&.size .. -1]
+                                    follow_on = (eval k.follow_on_substitute).inspect
+                                    newline = "#{$1}#{k.substitute} #{follow_on}#{remainder}"
+                                else
+                                    remainder = line[($1.size + $2.size) .. -1]
+                                    newline = "#{$1}#{k.substitute}#{remainder}"
+                                end
+                                
+                                pv "Line will become ----------> " + newline
+                                break
+                            end # end if regex        
+                        end # end keywords.each
+                        newlines << newline
+                    end # end lines.each
+                    # Add end lines to end of file if necessary
+                    newlines << "end" if needs_inner_end
+                    newlines << "end" if needs_top_level_end
+                    
+                    # Apply indentation
+                    newlines = TerseRuby::Format.indent(newlines) unless @no_formatting
+                    
+                    # Add newlines between the end of a method and the start of the next, if needed 
+                    newlines = TerseRuby::Format.space_lines(newlines) unless @no_formatting
+                    
+                    # Write out the new file
+                    File.open(new_filename, "w") do |new_f|
+                        newlines.each do |l|
+                            new_f.puts l
+                        end
+                    end
+                    puts "\nWrote file #{new_filename}"
+                end # end else
+            end # end ARGV.size
+            puts "\nTerse Ruby finished"
+        end # end scan_files
+
+        # Returns an "s" string if the size of the item (item.size) is > 1; returns "" otherwise
+        def self.plural_or_not item
+            item.size == 1 ? "" : "s"
+        end
+
+        def self.is_file? f
+            raise "Could not locate file at " + File.absolute_path(f) unless File.file?(f)
+        end
+
+        # Rules :
+        # Keep base-name, change ext. to .rb, write to current working dir
+        def self.gen_new_filename f
+            path = Dir.getwd
+            name = File.basename_no_ext f
+            ext = ".rb"
+            new_f = File.join(path, name) + ext
+
+            if File.file?(new_f)
+                puts "New file wll overwrite existing file " + new_f
+                raise "Overwrite flag not specified; will not overwrite existing file " + new_f if !@overwrite
+            end
+            new_f
+        end
+
+        def self.pv s
+            puts s if @verbose
+        end
+    end
+end

data/lib/terse_ruby.rb

@@ -0,0 +1,10 @@
+require "argv"
+require_relative "terse_ruby/scan"
+
+module TerseRuby
+
+    # Routing method to call the proper method
+    def self.scan_files argv
+        TerseRuby::Scan.scan_files argv
+    end
+end

data/terse_ruby.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name        = 'terse_ruby'
+  s.version     = '0.1.0'
+  s.licenses    = ['MIT']
+  s.summary     = "A utility to convert 'shorthand' Ruby into genuine Ruby."
+  s.description = "A utility to convert 'shorthand' Ruby into genuine Ruby. See README for more details."
+  s.authors     = ["Richard Morrisby"]
+  s.email       = 'rmorrisby@gmail.com'
+  s.homepage    = 'https://rubygems.org/gems/terse_ruby'
+  s.required_ruby_version = '>=1.9'
+  s.files = Dir['**/**']
+  s.test_files = Dir["test/test*.rb"]
+  s.has_rdoc = true
+end

data/test/expected_test_file.rb

@@ -0,0 +1,42 @@
+# test file for Terse Ruby
+
+require "things"
+
+class AClass
+	include stuff
+	def method1
+		require_relative "morethings"
+		puts "this is a real Ruby line"
+	end
+
+	def method2
+	end
+
+	def meth3
+		
+		attr_accessor :field1
+		attr_reader :field2
+		attr_writer :field3
+		
+	end
+end
+
+module AModule
+	
+	attr_writer :field4
+	attr_reader :field5
+	attr_accessor :field3 # deliberately the same name, but different accessor, as in AClass
+	
+	def m3
+		
+	end
+
+	def method2
+	end
+	
+	def c m r i d e a r w
+	end
+
+	def wraedirmc
+	end
+end

data/test/test_expansion.rb

@@ -0,0 +1,63 @@
+require "test/unit"
+require_relative "../lib/terse_ruby"
+
+class TestExpansion < Test::Unit::TestCase
+        
+    @@terse_file = "test_file.txt"
+    @@expanded_file = "test_file.rb"
+    @@premade_file = "expected_test_file.rb"
+    @@cmd = "ruby -e \"require 'terse_ruby'; TerseRuby.scan_files ARGV\" #{@@terse_file}"
+
+    def switch_dir
+        # Change this so we know where the expaneded file will be created
+        @previous_wd ||= Dir.getwd # Preserve the old wd so we can switch back to it after the test
+        Dir.chdir File.expand_path(File.dirname(__FILE__))    
+    end
+
+    def run_cmd
+        system @@cmd
+    end
+
+    # Switch to the same directory as this unit-test file, and check that the expected file is not present
+    def setup
+        switch_dir
+        raise "terse_ruby unit-tests found a pre-existing #{@@expanded_file} in #{Dir.getwd}; unit-tests will clean up after themselves but will not alter pre-existing files" if File.file? @@expanded_file
+        raise "terse_ruby unit-tests could not locate the starting test file #{@@terse_file} in #{Dir.getwd}" unless File.file? @@terse_file
+    end
+
+    # Tests that the test file is expanded with the expected name
+    def test_expanded_name
+        assert_false(File.file?(@@expanded_file), "Expanded test file #{@@expanded_file} already existed before running test")
+        run_cmd
+        assert(File.exists?(@@expanded_file), "terse_ruby did not expand #{@@terse_file} into a file with name #{@@expanded_file}")
+        assert(File.file?(@@expanded_file), "terse_ruby did not expand #{@@terse_file} into a file with name #{@@expanded_file}")
+    end
+
+    # Tests that the test file is expanded into the expected form
+    # Expand the file, then compare the two line-by-line
+    def test_expansion
+        run_cmd
+        assert(File.file?(@@expanded_file), "terse_ruby did not expand #{@@terse_file} into a file with name #{@@expanded_file}")
+        
+        expected_lines = File.readlines(@@premade_file)
+        actual_lines = File.readlines(@@expanded_file)
+        
+        assert_equal(expected_lines.size, actual_lines.size, "Expanded file did not have the expected number of lines")
+        
+        # As expected_lines and actual_lines are arrays, we can just use Array#==
+        assert_equal(expected_lines.sort, actual_lines.sort, "Expanded file did not have the expected lines in the expected order")
+        assert_equal(expected_lines, actual_lines, "Expanded file did not have the expected lines")
+    end
+
+    # Delete the expected file from the expected dir
+    def teardown
+        if File.file?(@@expanded_file)
+            count = File.delete @@expanded_file
+            raise "Teardown failed to delete expanded file #{@@expanded_file}" unless count == 1
+            raise "Teardown failed to delete expanded file #{@@expanded_file}" if File.file?(@@expanded_file)
+            puts "Teardown deleted expanded file #{@@expanded_file}"
+        end
+        Dir.chdir @previous_wd # restore the working directory to what it was previously
+    end
+    
+end

data/test/test_file.txt

@@ -0,0 +1,30 @@
+# test file for Terse Ruby
+
+req things
+
+c AClass
+    i stuff
+    d method1
+reqr morethings
+puts "this is a real Ruby line"
+e
+d method2
+d meth3
+
+a field1
+r field2
+w field3
+
+m AModule
+
+w field4
+r field5
+a field3 # deliberately the same name, but different accessor, as in AClass
+
+d m3
+
+d method2
+e
+
+    d c m r i d e a r w
+    d wraedirmc

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: terse_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Richard Morrisby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-26 00:00:00.000000000 Z
+dependencies: []
+description: A utility to convert 'shorthand' Ruby into genuine Ruby. See README for
+  more details.
+email: rmorrisby@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENCE.txt
+- README.txt
+- bin/terse_ruby.rb
+- lib/terse_ruby.rb
+- lib/terse_ruby/format.rb
+- lib/terse_ruby/keyword.rb
+- lib/terse_ruby/scan.rb
+- terse_ruby.gemspec
+- test/expected_test_file.rb
+- test/test_expansion.rb
+- test/test_file.txt
+homepage: https://rubygems.org/gems/terse_ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A utility to convert 'shorthand' Ruby into genuine Ruby.
+test_files:
+- test/test_expansion.rb