codgen 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in codgen.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Matthew Beatty
+
+MIT License
+
+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.md

@@ -0,0 +1,32 @@
+# Codgen
+
+A cross language template base code generator, capable of generating multiple applications from a common model.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'codgen'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install codgen
+
+## Usage
+
+    $ codgen codgen_config.json
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/codgen/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/codgen.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require 'ostruct'
+require 'json'
+require_relative '../lib/codgen'
+require_relative '../lib/codgen/logger'
+require 'fileutils'
+
+class CommandLineArguments
+  def initialize(arguments)
+    if arguments.count < 1
+      puts 'Help file placeholder'
+      exit 0
+    end
+
+    if arguments.count == 1
+      @json_config = arguments[0]
+    end
+  end
+
+  attr_reader :json_config
+end
+
+def get_file_contents(filepath)
+  if File.exist?(filepath)
+    File.read(filepath)
+  else
+    Logger.error('Could not find file "'+filepath+'"')
+  end
+end
+
+
+def write_file_contents(filepath, content)
+  dir = File.dirname(filepath)
+  FileUtils.mkpath(dir) unless Dir.exists?(dir)
+  File.write(filepath, content)
+end
+
+
+def main(args)
+  if args.json_config != nil
+    json_config_text = get_file_contents(args.json_config)
+    json_config = JSON.parse(json_config_text)
+    output = Codgen.run(json_config)
+    output.each do |path, text|
+      write_file_contents(path, text)
+    end
+  end
+end
+
+main(CommandLineArguments.new(ARGV))

data/codgen.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'codgen/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "codgen"
+  spec.version       = Codgen::VERSION
+  spec.authors       = ["Matthew Beatty"]
+  spec.email         = ["beattyml1@gmail.com"]
+  spec.summary       = 'Generate multiple applications from a common model written in JSON using template'
+  spec.description   = ''
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_runtime_dependency "mustache"
+  spec.add_runtime_dependency "json"
+  spec.add_runtime_dependency "activerecord"
+end

data/lib/codgen/auto_style.rb

@@ -0,0 +1,111 @@
+require 'active_support/inflector'
+require 'ostruct'
+module Codgen
+  module AutoStyle
+    public
+    def self.style(json_object)
+      if json_object.is_a?(Array)
+        json_object.each { |child| style(child) }
+      end
+
+      add_props = Hash.new
+      if json_object.is_a?(Hash)
+        json_object.each do |key, value|
+          if value.is_a?(Hash) || value.is_a?(Array)
+            style(value)
+            next
+          end
+
+          if key.index(/[@$ #]/)
+            add_props.store(key, value)
+          end
+        end
+      end
+
+      add_props.each do |key, value|
+        add_property_group(json_object, key, value, AutoStyle.method(:to_camel), '!camelCase')
+        add_property_group(json_object, key, value, AutoStyle.method(:to_cap_camel), '!CapCamel')
+        add_property_group(json_object, key, value, AutoStyle.method(:to_underscore), '!underscored')
+        add_property_group(json_object, key, value, AutoStyle.method(:to_camel), '!CAPS_UNDERSCORE')
+      end
+    end
+
+
+    def self.style_state_variable(input_string)
+      [to_camel(input_string), to_cap_camel(input_string), to_underscore(input_string), to_underscore(input_string)]
+    end
+
+
+    private
+    def self.add_property_group(json_object, key, value, translate, explicit_postfix)
+      should_translate_val = value != nil && value.is_a?(String) && key.index('@')
+      is_plural = key.index('?plural')
+
+      new_key = translate.call(key)
+      new_value = should_translate_val ? translate.call(value) : value
+      explicit_key = new_key + explicit_postfix
+
+      requantified = pluralize_singularize(new_key, explicit_key, new_value, is_plural, should_translate_val)
+
+      try_add_prop(json_object, new_key, new_value)
+      try_add_prop(json_object, explicit_key, new_value)
+      try_add_prop(json_object, requantified.short_key, requantified.value)
+      try_add_prop(json_object, requantified.explicit_key, requantified.value)
+    end
+
+    def self.pluralize_singularize(short_key, explicit_key, value, is_plural, should_translate_value)
+      return_obj = OpenStruct.new
+      if is_plural
+        return_obj.short_key = short_key.singularize
+        return_obj.explicit_key = explicit_key.singularize
+        return_obj.value = should_translate_value ? value.singularize : value
+      else
+        return_obj.short_key = short_key.pluralize
+        return_obj.explicit_key = explicit_key.pluralize
+        return_obj.value = should_translate_value ? value.pluralize : value
+      end
+      return_obj
+    end
+
+
+    def self.try_add_prop(json_object, key, value)
+      unless json_object.has_key?(key)
+        json_object.store(key, value)
+      end
+    end
+
+
+    def self.to_universal(input_string)
+      output_string = input_string.tr('$?@', '')
+      output_string.split(' ')
+    end
+
+
+    def self.to_cap_camel(input_string)
+      universal = to_universal(input_string)
+      universal.each {|word| word[0] = word[0].upcase}
+      universal.join('')
+    end
+
+
+    def self.to_camel(input_string)
+      universal = to_universal(input_string)
+      universal[1...universal.count].each {|word| word[0] = word[0].upcase}
+      universal.join('')
+    end
+
+
+    def self.to_underscore(input_string)
+      universal = to_universal(input_string)
+      output = universal.join('_')
+      output.downcase
+    end
+
+
+    def self.to_allcaps_underscore(input_string)
+      universal = to_universal(input_string)
+      output = universal.join('_')
+      output.upcase
+    end
+  end
+end

data/lib/codgen/constants.rb

@@ -0,0 +1,5 @@
+module Codgen
+  module RegularExpressions
+    IDENTIFIER_REGEX = /[a-zA-Z0-9_%]+/
+  end
+end

data/lib/codgen/debug_helper.rb

@@ -0,0 +1,15 @@
+module DebugHelper
+  @@event_log = nil
+
+  def self.write_file(name, text)
+    File.write('../debug_data/'+name, text)
+  end
+
+  def self.log_event(message)
+    if @@event_log == nil
+      @@event_log = File.new('../debug_data/event_log', 'w+')
+    end
+
+      @@event_log.write("#{Time.now}: #{message}\n")
+  end
+end

data/lib/codgen/flattener.rb

@@ -0,0 +1,32 @@
+module Codgen
+  module Flattener
+
+    # @param [Hash] data_root: the JSON root hash
+    # @param [Array[String]] properties
+    # @return [Array, Hash]
+    def self.merge(data_root, properties)
+      current = data_root
+      obj_out = Hash.new
+      properties.each { |property|
+        current.each {|prop, val| obj_out[prop] = val}
+        current = current[property]
+      }
+
+      if current.is_a?(Hash)
+        current.each {|prop, val| obj_out[prop] = val}
+        return obj_out
+      elsif current.is_a?(Array)
+        array_out = Array.new
+        current.each { |child|
+          if child.is_a?(Hash)
+            array_obj = Hash.new
+            obj_out.each {|prop, val| array_obj[prop] = val}
+            child.each {|prop, val| array_obj[prop] = val}
+            array_out.push(array_obj)
+          end
+        }
+        return array_out
+      end
+    end
+  end
+end

data/lib/codgen/logger.rb

@@ -0,0 +1,8 @@
+module Codgen
+  module Logger
+    def self.error(message)
+      puts message
+      exit 1
+    end
+  end
+end

data/lib/codgen/mapping.rb

@@ -0,0 +1,40 @@
+module Codgen
+  module Mapping
+    def self.map_object(json_data, json_map_data)
+      if json_data != nil && json_data.is_a?(Array)
+        json_data.each do |item|
+          map_object(item, json_map_data)
+        end
+        return
+      end
+
+      add_entries = Hash.new
+      json_data.each do |key, value|
+        if value != nil && value.is_a?(Array) || value.is_a?(Hash)
+          map_object(value, json_map_data)
+          next
+        end
+
+        map = json_map_data[key]
+        if map != nil
+          map.each do |output_key, value_map|
+            unless json_data.has_key?(output_key)
+              output_value = value
+              value_map.each do |match_expr, map_value|
+                if Regexp.new(match_expr).match(value)
+                  output_value = map_value
+                  break
+                end
+              end
+              add_entries.store(output_key, output_value)
+            end
+          end
+        end
+      end
+
+      add_entries.each do |key, value|
+        json_data.store(key, value)
+      end
+    end
+  end
+end

data/lib/codgen/statement.rb

@@ -0,0 +1,163 @@
+require_relative 'constants'
+require_relative 'logger'
+
+# Not currently used but will be for an up coming feature that used be implemented in an older version
+module Codgen
+  class Statement
+    include RegularExpressions
+    def initialize(operator=nil)
+      @words = Array.new
+      @operator = operator
+    end
+
+    def evaluate(get_val)
+      if @operator == nil
+        expand
+      end
+
+      current_val = nil
+      @words.each do |child|
+        current_val = accumulate(current_val, child, @operator, get_val)
+      end
+      current_val
+    end
+
+    attr_reader :operator
+    attr_reader :words
+
+    def accumulate(before, child, operator, get_val)
+      if operator == nil && child.is_a?(Statement)
+        accumulate(before, child, child.operator, get_val)
+      else
+        value = child.is_a?(String) ? get_val.call(child) : child.evaluate(get_val)
+        case operator
+          when :and
+            before = before != nil ? before : true
+            before && value
+          when :or
+            before = before != nil ? before : false
+            before || value
+          when :not
+            !value
+          else
+            value
+        end
+      end
+    end
+
+    def expand
+      expand_not
+      expand_and
+      expand_or
+    end
+
+    def parse(text)
+      count = -1
+      text.each_char do |current_char|
+        count+=1
+        if current_char == ' '
+          next 1
+        end
+
+        if current_char.index(IDENTIFIER_REGEX)
+          if @words.length > 0 && @words[-1].index(IDENTIFIER_REGEX)
+            @words[-1] = @words[-1] + current_char
+          else
+            @words.push(current_char)
+          end
+        elsif current_char.index(/[&|!]/)
+          @words.push(current_char)
+        elsif current_char == '('
+          @words.push(Statement.new)
+          count += @words[-1].parse(text[count...text.length])
+        elsif current_char == ')'
+          return count
+        end
+      end
+    end
+
+    def expand_not
+      new_words = Array.new
+      @words.each do |word|
+        if word.is_a?(Statement)
+          new_words.push(word)
+        elsif word.index(/not|!/)
+          if new_words[-1].is_a?(Statement) && new_words[-1].operator == :not
+            new_words.delete_at(-1)
+          else
+            new_words.push(Statement.new(:not))
+          end
+        else
+          if new_words[-1].is_a?(Statement) && new_words[-1].operator == :not && new_words[-1].words.count == 0
+            new_words[-1].words.push(word)
+          else
+            new_words.push(word)
+          end
+        end
+      end
+      @words = new_words
+    end
+
+    def expand_and
+      new_words = Array.new
+      index = -1
+      skip = false
+      @words.each do |word|
+        index+=1
+        if skip
+          skip = false
+          next
+        end
+        if word.is_a?(Statement)
+          new_words.push(word)
+        elsif word.index(/and|&/)
+          if new_words.count > 0 && @words.count > index + 1
+            left = new_words[-1]
+            new_words.delete_at(-1)
+            new_words.push(Statement.new(:and))
+            new_words[-1].words.push(left)
+            new_words[-1].words.push(@words[index+1])
+            skip = true
+            next
+          else
+            throw 'Operator must have a left and a right side'
+          end
+        else
+          new_words.push(word)
+        end
+      end
+      @words = new_words
+    end
+
+    def expand_or
+      new_words = Array.new
+      index = -1
+      skip = false
+      @words.each do |word|
+        index+=1
+        if skip
+          skip = false
+          next
+        end
+        if word.is_a?(Statement)
+          new_words.push(word)
+        elsif word.index(/or|\|/)
+          if new_words.count > 0 && @words.count > index + 1
+            left = new_words[-1]
+            new_words.delete_at(-1)
+            new_words.push(Statement.new(:or))
+            new_words[-1].words.push(left)
+            new_words[-1].words.push(@words[index+1])
+            skip = true
+            next
+          else
+            throw 'Operator must have a left and a right side'
+          end
+        else
+          new_words.push(word)
+        end
+      end
+      @words = new_words
+    end
+  end
+end

data/lib/codgen/template.rb

@@ -0,0 +1,40 @@
+require 'mustache'
+require_relative 'flattener'
+require_relative 'logger'
+
+module Codgen
+  class Template
+    # @param [JSON_Hash] template_info
+    # @param [JSON_Hash] data_root
+    def initialize(template_info, data_root)
+      @input_path = template_info['in']
+      @out_raw = template_info['out']
+      source_raw = template_info['source']
+      source_location = source_raw != nil ? source_raw.split('.') : []
+      @data = Flattener.merge(data_root, source_location)
+      @template = Template.get_template(@input_path)
+    end
+
+    def fill_template
+      if @data.is_a?(Array)
+        output = Hash.new
+        @data.each { |data|
+          output.store(Mustache.render(@out_raw, data), Mustache.render(@template, data))
+        }
+        return output
+      elsif @data.is_a?(Hash)
+      return { Mustache.render(@out_raw, data) => Mustache.render(@template, @data) }
+      end
+    end
+
+    def self.get_template(path)
+      if File.exist?(path)
+        File.read(path)
+      else
+        Logger.error('Could not find file "'+path+'"')
+      end
+    end
+
+    attr_reader :data, :input_path, :template # Used to unit test
+  end
+end

data/lib/codgen/version.rb

@@ -0,0 +1,3 @@
+module Codgen
+  VERSION = "0.0.1"
+end

data/lib/codgen.rb

@@ -0,0 +1,59 @@
+require_relative 'codgen/version'
+require_relative 'codgen/auto_style'
+require_relative 'codgen/mapping'
+require_relative 'codgen/logger'
+require_relative 'codgen/template'
+
+module Codgen
+  def self.run(json_config)
+    map = json_config['map']
+    map = get_data_if_not_data(map)
+
+    json_data  = json_config['data']
+    json_data = get_data_if_not_data(json_data)
+    json_data = map_and_style(map, json_data)
+
+    #File.write('temp.json', JSON.pretty_unparse(json_data)) # frequently used debug code
+
+    filled_templates = Array.new
+
+    templates = json_config['templates']
+    templates.each do |template_info|
+
+      template = Template.new(template_info, json_data)
+      template.fill_template.each {|filled_template| filled_templates.push(filled_template)}
+    end
+
+    filled_templates
+  end
+
+  def self.get_data_if_not_data(filepath_or_data)
+    if filepath_or_data != nil
+      if filepath_or_data.is_a?(String)
+        file = File.read(filepath_or_data)
+        JSON.parse(file)
+      elsif filepath_or_data.is_a?(Hash)
+        filepath_or_data
+      else
+        Logger.error('In json config file: "map" must be either a filepath or a json object.')
+      end
+    end
+  end
+
+
+  class FilledTemplate
+    attr_accessor :path
+    attr_accessor :text
+  end
+
+
+  def self.map_and_style(map_data, json_data)
+    if map_data
+      Mapping.map_object(json_data, map_data)
+    end
+
+    AutoStyle.style(json_data)
+
+    json_data
+  end
+end

data/test/behavior/basic_test.rb

@@ -0,0 +1,10 @@
+require 'fileutils'
+require_relative 'test_utils'
+
+puts `ruby ../Source/codgen.rb config.json`
+
+error = TestUtils.recursive_compare('expected_output', 'Output')
+
+unless error
+  puts 'Success!'
+end

data/test/behavior/output_spec.rb

@@ -0,0 +1,36 @@
+require 'rspec'
+require 'fileutils'
+require_relative 'test_utils'
+
+describe 'Application' do
+  $expectation_directory = 'expected_output'
+  $output_directory = 'Output'
+  before :all do
+
+    FileUtils.rm_rf($output_directory)
+
+    puts `../../bin/codgen.rb config.json`
+  end
+
+  it 'should produce all expected files' do
+    files_and_folders = Dir.glob($expectation_directory+'/**/*')
+    files_and_folders.each do |expected_file_path|
+      if File.file?(expected_file_path)
+        output_file_path = expected_file_path.sub($expectation_directory, $output_directory)
+        expect(File.exist?(output_file_path)).to be_truthy
+      end
+    end
+  end
+
+
+  files_and_folders = Dir.glob($expectation_directory+'/**/*')
+  files_and_folders.each do |expected_file_path|
+    if File.file?(expected_file_path)
+      output_file_path = expected_file_path.sub($expectation_directory, $output_directory)
+      it "should produce file: '#{output_file_path}' that is the same as '#{expected_file_path}'" do
+        expect(File.exist?(output_file_path)).to be_truthy
+        expect(FileUtils.cmp(output_file_path, expected_file_path)).to be_truthy
+      end
+    end
+  end
+end

data/test/behavior/test_utils.rb

@@ -0,0 +1,16 @@
+module TestUtils
+  def self.recursive_compare(expectation_directory, output_directory)
+    files_and_folders = Dir.glob(expectation_directory+'/**/*')
+    error = false
+    files_and_folders.each do |expected_file_path|
+      if File.file?(expected_file_path)
+        output_file_path = expected_file_path.sub(expectation_directory, output_directory)
+        unless FileUtils.cmp(expected_file_path, output_file_path)
+          puts "Error: '#{output_file_path}' does not match '#{expected_file_path}"
+          error = true
+        end
+      end
+    end
+    return error
+  end
+end