command_builder_generator 0.0.1

data/lib/command_builder_generator.rb

@@ -0,0 +1 @@
+require_relative 'command_builder_generator/code_generator'

data/lib/command_builder_generator/code_generator.rb

@@ -0,0 +1,82 @@
+require 'erb'
+require_relative 'command_definition'
+require_relative 'command_code_names'
+require_relative 'ruby_code_writer'
+require_relative 'node_code_generator'
+require 'fileutils'
+
+module CommandBuilderGenerator
+  class CodeGenerator
+
+    def initialize(definition_file)
+      @definition_file = definition_file
+    end
+
+    def execute
+      puts "Processing: #{File.basename @definition_file}"
+      d = CommandDefinition.new File.new(@definition_file)
+      d.versions.each { |v| process_version d.command, v }
+    end
+
+    private
+
+    def process_version(command, version)
+      generate_command_module command, version
+      generate_version_module command, version
+      FileUtils.cp_r File.expand_path(File.dirname(__FILE__) + '/lib'), Dir.getwd
+    end
+
+    def generate_command_module(command, version)
+      code_names = CommandCodeNames.new command, version
+
+      model = {
+          module_name: code_names.command_module_name,
+          factory_method_name: code_names.command_factory_method_name,
+          command_name: command.command_name
+      }
+
+      template_file = File.expand_path(File.dirname(__FILE__) + '/templates/command_module.erb')
+      result_file = "#{code_names.command_factory_method_name}.rb"
+      sub_template model, template_file, result_file
+    end
+
+    def generate_version_module(command, version)
+      code_names = CommandCodeNames.new command, version
+
+      model = {
+          command_factory_method_signature: code_names.command_factory_method_signature,
+          version_factory_method_signature: code_names.version_factory_method_signature,
+          create_method_signature: code_names.create_method_signature,
+          create_method_call: code_names.create_method_call,
+          command_initializer_call: code_names.command_initializer_call,
+          command_module_name: code_names.command_module_name,
+          version_module_name: code_names.version_module_name,
+          version: version,
+          command_class: generate_command_class(command),
+          factory_method_name: code_names.command_factory_method_name,
+          command_factory_method_call: code_names.command_factory_method_call,
+          command_name: command.command_name
+      }
+
+      template_file = File.expand_path(File.dirname(__FILE__) + '/templates/version_module.erb')
+      result_file = File.join "#{code_names.version_factory_method_name}.rb"
+      sub_template model, template_file, result_file
+    end
+
+    def sub_template(model, template_file, result_file)
+      template = ERB.new File.read(template_file)
+      result = template.result(binding)
+      File.open(result_file, 'w') { |f| f.write result }
+    end
+
+    def generate_command_class(command)
+      stream = StringIO.new
+      writer = RubyCodeWriter.new stream
+      writer.indent = 3
+      node_code_generator = NodeCodeGenerator.new command, command, writer
+      node_code_generator.render
+      stream.string
+    end
+
+  end
+end

data/lib/command_builder_generator/command.rb

@@ -0,0 +1,50 @@
+require 'yaml'
+require_relative 'string_extensions'
+require_relative 'node'
+
+module CommandBuilderGenerator
+  class Command < Node
+
+    attr_reader :command_name
+
+    def initialize(command_def)
+      hash = Command.command_hash command_def
+      command_text = hash.keys[0]
+      command_name = Command.command_name command_text
+      node_def = command_text[command_name.length, command_text.length]
+      super node_def
+      Command.process_array hash.values[0], self
+      @command_name = command_name
+    end
+
+    def node_name
+      @node_name ||= node_alias || @command_name
+    end
+
+    private
+
+    def Command.command_name(command_text)
+      command_text[/^([-\.\w]+)/, 1]
+    end
+
+    def Command.command_hash(command_text)
+      yaml = command_text.split(String::NEW_LINE).map { |l| l.gsub(/^( *)(\S.+)$/, '\1- "\2":') }.join String::NEW_LINE
+      array = YAML.load yaml
+      array[0]
+    end
+
+    def Command.process_array(array, parent_node=nil)
+      array ||= []
+      array.each { |hash| Command.process_hash hash, parent_node }
+    end
+
+    def Command.process_hash(hash, parent_node)
+      hash.each_pair do |node_text, child_nodes|
+        node = Node.new " #{node_text}"
+        parent_node.child_nodes << node
+        process_array child_nodes, node
+      end
+    end
+
+  end
+end

data/lib/command_builder_generator/command_argument.rb

@@ -0,0 +1,30 @@
+module CommandBuilderGenerator
+  class CommandArgument
+
+    def initialize(arg_text, required=true)
+      @arg_text = arg_text
+      @required = required
+    end
+
+    def arg_name
+      @arg_name ||= @arg_text[/<(\w+)/, 1]
+    end
+
+    def key_value_separator
+      @key_value_separator ||= @arg_text[/(\W)\W>/, 1]
+    end
+
+    def delimiter
+      @delimiter ||= @arg_text[/(\W)>/, 1]
+    end
+
+    def required?
+      @required
+    end
+
+    def optional?
+      !required?
+    end
+
+  end
+end

data/lib/command_builder_generator/command_code_names.rb

@@ -0,0 +1,77 @@
+require_relative 'string_extensions'
+
+module CommandBuilderGenerator
+  class CommandCodeNames
+
+    def initialize(command, version=nil)
+      @command = command
+      @compact_version = version.to_s.gsub('.', '_')
+    end
+
+    def command_module_name
+      @command.node_name.camelcase
+    end
+
+    def version_module_name
+      "V#{@compact_version}"
+    end
+
+    def command_factory_method_name
+      @command.node_name.downcase.snakecase
+    end
+
+    def command_factory_method_signature
+      format_method command_factory_method_name, factory_method_args
+    end
+
+    def version_factory_method_name
+      "#{command_factory_method_name}_#{@compact_version.downcase.snakecase}"
+    end
+
+    def version_factory_method_signature
+      format_method version_factory_method_name, factory_method_args
+    end
+
+    def create_method_signature
+      format_method 'self.create', factory_method_args
+    end
+
+    def create_method_call
+      format_method "CommandBuilder::#{command_module_name}::#{version_module_name}.create", initializer_values
+    end
+
+    def command_factory_method_call
+      format_method command_factory_method_name, initializer_values
+    end
+
+    def command_initializer_call
+      format_method "#{class_name}.new", initializer_values
+    end
+
+    private
+
+    def format_method(method_name, method_args)
+      method_args = method_args.join ', '
+      result = method_name
+      result << "(#{method_args})" unless method_args.empty?
+      result
+    end
+
+    def factory_method_args
+      @command.args.map do |arg|
+        arg_name = arg.arg_name.snakecase
+        arg_name << '=nil' if arg.optional?
+        arg_name
+      end
+    end
+
+    def initializer_values
+      @command.args.map { |arg| arg.arg_name.snakecase }
+    end
+
+    def class_name
+      @command.node_name.camelcase
+    end
+
+  end
+end

data/lib/command_builder_generator/command_definition.rb

@@ -0,0 +1,25 @@
+require_relative 'command'
+require_relative 'version'
+require_relative 'string_extensions'
+
+module CommandBuilderGenerator
+  class CommandDefinition
+
+    attr_reader :versions, :command
+
+    def initialize(stream)
+      s = stream.read
+      @versions = parse_versions s.first_line
+      @command = Command.new s.strip_first_line
+    end
+
+    private
+
+    def parse_versions(line)
+      versions = line.split_and_strip ','
+      versions.each { |v| Version.new v }
+      versions
+    end
+
+  end
+end

data/lib/command_builder_generator/fragment.rb

@@ -0,0 +1,35 @@
+require_relative 'command_argument'
+
+module CommandBuilderGenerator
+  class Fragment
+
+    def initialize(fragment_def)
+      @fragment_def = fragment_def
+    end
+
+    def fragment_text
+      @fragment_text ||= optional? ? @fragment_def[1, @fragment_def.length - 2] : @fragment_def
+    end
+
+    def required?
+      !optional?
+    end
+
+    def optional?
+      @optional ||= @fragment_def.start_with?('[') && @fragment_def.end_with?(']')
+    end
+
+    def args
+      @args ||= fragment_text.scan(/<.+?>/).flatten.map { |m| CommandArgument.new m, required? }
+    end
+
+    def arg_names
+      @arg_names ||= args.map { |a| a.arg_name }
+    end
+
+    def has_args?
+      @has_args ||= !args.empty?
+    end
+
+  end
+end

data/lib/command_builder_generator/lib/argument_formatter.rb

@@ -0,0 +1,22 @@
+require_relative 'argument_formatters/array_argument_formatter'
+require_relative 'argument_formatters/hash_argument_formatter'
+require_relative 'argument_formatters/string_argument_formatter'
+
+module CommandBuilder
+  class ArgumentFormatter
+
+    def format(argument, options={})
+
+      formatter = case
+                    when argument.kind_of?(Array)
+                      ArrayArgumentFormatter.new options[:delimiter]
+                    when argument.kind_of?(Hash)
+                      HashArgumentFormatter.new options[:delimiter], options[:key_value_separator]
+                    else
+                      StringArgumentFormatter.new
+                  end
+      formatter.format argument
+    end
+
+  end
+end

data/lib/command_builder_generator/lib/argument_formatters/array_argument_formatter.rb

@@ -0,0 +1,22 @@
+require_relative 'string_argument_formatter'
+
+module CommandBuilder
+  class ArrayArgumentFormatter
+
+    def initialize(delimiter)
+      @delimiter = delimiter
+      @string_argument_formatter = StringArgumentFormatter.new
+    end
+
+    def format(argument)
+      argument.map { |v| format_string_argument v }.join @delimiter
+    end
+
+    private
+
+    def format_string_argument(s)
+      @string_argument_formatter.format s
+    end
+
+  end
+end

data/lib/command_builder_generator/lib/argument_formatters/hash_argument_formatter.rb

@@ -0,0 +1,27 @@
+require_relative 'string_argument_formatter'
+
+module CommandBuilder
+  class HashArgumentFormatter
+
+    def initialize(delimiter, key_value_separator)
+      @delimiter = delimiter
+      @key_value_separator = key_value_separator
+      @string_argument_formatter = StringArgumentFormatter.new
+    end
+
+    def format(argument)
+      argument.map { |k, v| format_pair k, v }.join @delimiter
+    end
+
+    private
+
+    def format_pair(k, v)
+      format_string_argument(k) + @key_value_separator + format_string_argument(v)
+    end
+
+    def format_string_argument(s)
+      @string_argument_formatter.format s
+    end
+
+  end
+end

data/lib/command_builder_generator/lib/argument_formatters/string_argument_formatter.rb

@@ -0,0 +1,17 @@
+module CommandBuilder
+  class StringArgumentFormatter
+
+    def format(argument)
+      s = argument
+      case
+        when s =~ /$".*"^/
+          s
+        when s.include?(' ')
+          %Q["#{s}"]
+        else
+          s
+      end
+    end
+
+  end
+end

data/lib/command_builder_generator/lib/command_base.rb

@@ -0,0 +1,20 @@
+require_relative 'argument_formatter'
+
+module CommandBuilder
+  class CommandBase
+
+    attr_reader :passwords
+
+    def initialize
+puts 'aaaa'
+      @s = StringIO.new
+      @f = ArgumentFormatter.new
+      @passwords = []
+    end
+
+    def to_s
+      @s.string
+    end
+
+  end
+end

data/lib/command_builder_generator/node.rb

@@ -0,0 +1,65 @@
+require_relative 'fragment'
+
+module CommandBuilderGenerator
+  class Node
+
+    def initialize(node_def)
+      @node_def = node_def
+    end
+
+    def child_nodes
+      @child_nodes ||= []
+    end
+
+    def branch?
+      !child_nodes.empty?
+    end
+
+    def leaf?
+      child_nodes.empty?
+    end
+
+    def node_name
+      @node_name ||= node_alias || (starts_with_arg? ? first_arg_name : words_preceding_args)
+    end
+
+    def fragments
+      @fragments ||= @node_def.gsub(/ \(.+?\)/, '').gsub(']', ']|').gsub('[', '|[').split('|').compact.map { |f| Fragment.new f }
+    end
+
+    def args
+      required_args + optional_args
+    end
+
+    protected
+
+    def required_args
+      select_args { |a| a.required? }
+    end
+
+    def optional_args
+      select_args { |a| a.optional? }
+    end
+
+    def starts_with_arg?
+      words_preceding_args.empty?
+    end
+
+    def first_arg_name
+      @node_def[/<(.+?)>/, 1]
+    end
+
+    def words_preceding_args
+      @node_def.gsub(/<.*/, '').gsub(/\W/, ' ').strip
+    end
+
+    def node_alias
+      @node_def[/\((.+?)\)/, 1]
+    end
+
+    def select_args
+      fragments.map { |f| f.args.map { |a| a if yield a } }.flatten.compact
+    end
+
+  end
+end

data/lib/command_builder_generator/node_code_generator.rb

@@ -0,0 +1,99 @@
+require_relative 'string_extensions'
+require_relative 'node'
+require_relative 'node_code_names'
+
+module CommandBuilderGenerator
+  class NodeCodeGenerator
+
+    def initialize(node, command, writer)
+      @node = node
+      @command = command
+      @writer = writer
+    end
+
+    def render
+      render_branch_node if @node.branch?
+      render_leaf_node if @node.leaf?
+    end
+
+    def render_method
+      @writer.write_method node_code_names.method_name, node_code_names.method_args do
+        if @node.branch?
+          render_branch_node_method_body
+        else
+          render_leaf_node_method_body
+          @writer.write_line '@s << yield if block_given?'
+          @writer.write_line 'self'
+        end
+      end
+    end
+
+    private
+
+    def render_branch_node
+      @writer.write_class node_code_names.class_name, 'CommandBase' do
+        render_constructor
+        @node.child_nodes.each do |n|
+          generator = NodeCodeGenerator.new n, @command, @writer
+          generator.render_method
+        end
+      end
+      render_child_nodes
+    end
+
+    def render_leaf_node
+      render_child_nodes
+    end
+
+    def render_child_nodes
+      @node.child_nodes.each do |n|
+        generator = NodeCodeGenerator.new n, @command, @writer
+        generator.render
+      end
+    end
+
+    def render_constructor
+      @writer.write_method 'initialize', node_code_names.method_args do
+        @writer.write_line 'super()'
+        render_leaf_node_method_body
+      end
+    end
+
+    def render_branch_node_method_body
+      args = node_code_names.initializer_values
+      @writer.write_line "#{node_code_names.class_name}.new #{args.join ', '}"
+    end
+
+    def render_leaf_node_method_body
+      @node.fragments.each { |f| write_append_statement f }
+    end
+
+    def write_append_statement(fragment)
+      return if fragment.fragment_text.empty?
+      unless_condition = fragment.arg_names.map { |a| "#{a.snakecase}.nil?" }.join ' or '
+      statement = "@s << #{append_arg fragment}"
+      statement << " unless #{unless_condition}" if fragment.optional? and fragment.has_args?
+      @writer.write_line statement
+    end
+
+    def append_arg(fragment)
+      value = fragment.fragment_text.gsub(/<.+?>/) do |m|
+        arg = CommandArgument.new m
+        is_password = arg.arg_name.downcase.include? 'password'
+
+        if is_password
+          "\#{format_password #{arg.arg_name.snakecase}}"
+        else
+          format_args = [arg.arg_name.snakecase, [arg.delimiter, arg.key_value_separator].compact.map { |v| "'#{v}'" }].flatten
+          "\#{@f.format #{format_args.join ', '}}"
+        end
+      end
+      value.include?('#{') ? %Q["#{value}"] : "'#{value}'"
+    end
+
+    def node_code_names
+      @node_code_names ||= NodeCodeNames.new @node
+    end
+
+  end
+end

data/lib/command_builder_generator/node_code_names.rb

@@ -0,0 +1,31 @@
+require_relative 'string_extensions'
+
+module CommandBuilderGenerator
+  class NodeCodeNames
+
+    def initialize(node)
+      @node = node
+    end
+
+    def class_name
+      @node.node_name.camelcase
+    end
+
+    def method_name
+      @node.node_name.snakecase
+    end
+
+    def method_args
+      @node.args.map do |arg|
+        arg_name = arg.arg_name.snakecase
+        arg_name << '=nil' if arg.optional?
+        arg_name
+      end
+    end
+
+    def initializer_values
+      @node.args.map { |arg| arg.arg_name.snakecase }
+    end
+
+  end
+end

data/lib/command_builder_generator/ruby_code_writer.rb

@@ -0,0 +1,61 @@
+module CommandBuilderGenerator
+  class RubyCodeWriter
+
+    INDENT_SPACES = 2
+
+    attr_accessor :indent
+
+    def initialize(stream)
+      @stream = stream
+      @indent = 0
+    end
+
+    def indent
+      @indent += 1
+      if block_given?
+        yield
+        dedent
+      end
+    end
+
+    def dedent
+      @indent -= 1
+    end
+
+    def write(code)
+      @stream.print code
+    end
+
+    def write_line(line='')
+      @stream.puts line.rjust(line.length + @indent * INDENT_SPACES, ' ')
+    end
+
+    def write_block(line)
+      write_line line
+      indent
+      yield
+      dedent
+      write_line 'end'
+      line
+    end
+
+    def write_module(module_name)
+      write_block("module #{module_name}") { yield }
+    end
+
+    def write_class(class_name, base_class_name=nil)
+      line = "class #{class_name}"
+      line << " < #{base_class_name}" if base_class_name
+      write_block(line) { yield }
+    end
+
+    def write_method(method_name, *args)
+      args = [args].flatten
+      line = "def #{method_name}"
+      line << "(#{args.join ', '})" unless args.empty?
+      write_block(line) { yield }
+      @stream.puts
+    end
+
+  end
+end

data/lib/command_builder_generator/string_extensions.rb

@@ -0,0 +1,35 @@
+
+  class String
+
+    NEW_LINE = "\n"
+
+    def camelcase
+      words.join
+    end
+
+    def snakecase
+      words.join('_').downcase
+    end
+
+    def first_line
+      match(/^.*$/)[0]
+    end
+
+    def strip_first_line
+      first_line_index = self.index NEW_LINE
+      return '' unless first_line_index
+      self[first_line_index+1..self.length-1]
+    end
+
+    def split_and_strip(pattern)
+      split(pattern).map { |s| s.strip }
+    end
+
+    private
+
+    def words
+      result = self =~ /^[A-Z]+$/ ? downcase : self
+      result.gsub(/[\W_]/, ' ').gsub(/[A-Z*]/, ' \0').split(' ').map { |s| s.capitalize }
+    end
+
+  end

data/lib/command_builder_generator/version.rb

@@ -0,0 +1,45 @@
+module CommandBuilderGenerator
+  class Version
+
+    VERSION_REGEX = '(?:\d+\.)+(?:\d+)'
+    DELIMITER = '.'
+
+    attr_accessor :version
+
+    def initialize(version)
+      raise "#{version} is not a valid version." unless Version.is_valid? version
+      @version = version
+    end
+
+    def compact
+      first 2, '_'
+    end
+
+    def first(count, delimiter=DELIMITER)
+       to_a.first(count).join(delimiter)
+     end
+
+    def to_s
+      @version
+    end
+
+    def to_a
+      @version.split DELIMITER
+    end
+
+    def self.match(value)
+      exp = Regexp.new VERSION_REGEX
+      version = value.scan(exp)[0]
+      return unless version
+      Version.new(version)
+    end
+
+    private
+
+    def self.is_valid?(version)
+      exp = Regexp.new "^#{VERSION_REGEX}$"
+      version.scan(exp)[0] != nil
+    end
+
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: command_builder_generator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matthew Riley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70225892059240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: *70225892059240
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70225892058760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: *70225892058760
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: &70225892058300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: *70225892058300
+description: Description
+email: matthew@matthewriley.name
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/command_builder_generator/code_generator.rb
+- lib/command_builder_generator/command.rb
+- lib/command_builder_generator/command_argument.rb
+- lib/command_builder_generator/command_code_names.rb
+- lib/command_builder_generator/command_definition.rb
+- lib/command_builder_generator/fragment.rb
+- lib/command_builder_generator/lib/argument_formatter.rb
+- lib/command_builder_generator/lib/argument_formatters/array_argument_formatter.rb
+- lib/command_builder_generator/lib/argument_formatters/hash_argument_formatter.rb
+- lib/command_builder_generator/lib/argument_formatters/string_argument_formatter.rb
+- lib/command_builder_generator/lib/command_base.rb
+- lib/command_builder_generator/node.rb
+- lib/command_builder_generator/node_code_generator.rb
+- lib/command_builder_generator/node_code_names.rb
+- lib/command_builder_generator/ruby_code_writer.rb
+- lib/command_builder_generator/string_extensions.rb
+- lib/command_builder_generator/version.rb
+- lib/command_builder_generator.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Summary
+test_files: []