command_builder 0.0.2 → 0.0.3

data/lib/command_builder/code_generator/code_generator.rb

@@ -0,0 +1,88 @@
+require 'erb'
+require_relative 'command_definition'
+require_relative 'command_code_names'
+require_relative 'ruby_code_writer'
+require_relative 'node_code_generator'
+
+module CommandBuilder
+  module CodeGenerator
+    class Generator
+
+      def initialize(options={})
+        @definitions_dir = 'command_definitions'
+        @command_builders_dir = options[:command_builders_dir] || 'lib/command_builder'
+      end
+
+      def execute
+        pattern = File.join @definitions_dir, '*.txt'
+        Dir[pattern].each { |f| process_definition f }
+      end
+
+      private
+
+      def process_definition(definition_file)
+        puts "Processing: #{File.basename definition_file}"
+        d = CommandDefinition.new File.new(definition_file)
+        d.versions.each { |v| process_version d.command, v }
+      end
+
+      def process_version(command, version)
+        generate_command_module command, version
+        generate_version_module command, version
+      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 = File.join @command_builders_dir, "#{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 @command_builders_dir, "#{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
+end

data/lib/command_builder/code_generator/command.rb

@@ -0,0 +1,52 @@
+require 'yaml'
+require_relative 'string_extensions'
+require_relative 'node'
+
+module CommandBuilder
+  module CodeGenerator
+    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
+end

data/lib/command_builder/code_generator/command_argument.rb

@@ -0,0 +1,32 @@
+module CommandBuilder
+  module CodeGenerator
+    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
+end

data/lib/command_builder/code_generator/command_code_names.rb

@@ -0,0 +1,80 @@
+require_relative 'string_extensions'
+
+module CommandBuilder
+  module CodeGenerator
+    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
+        result = @compact_version =~ /^\d/ ? "V#{@compact_version}" : @compact_version
+        result.camelcase
+      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 "FluentCommandBuilder::#{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", %w(b) + 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
+end

data/lib/command_builder/code_generator/command_definition.rb

@@ -0,0 +1,26 @@
+require_relative 'command'
+require_relative 'version'
+
+module CommandBuilder
+  module CodeGenerator
+    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
+end

data/lib/command_builder/code_generator/fragment.rb

@@ -0,0 +1,37 @@
+require_relative 'command_argument'
+
+module CommandBuilder
+  module CodeGenerator
+    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
+end

data/lib/command_builder/code_generator/node.rb

@@ -0,0 +1,67 @@
+require_relative 'fragment'
+
+module CommandBuilder
+  module CodeGenerator
+    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
+end

data/lib/command_builder/code_generator/node_code_generator.rb

@@ -0,0 +1,101 @@
+require_relative 'string_extensions'
+require_relative 'node'
+require_relative 'node_code_names'
+
+module CommandBuilder
+  module CodeGenerator
+    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 'yield @b 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', 'underlying_builder', node_code_names.method_args do
+          @writer.write_line 'super underlying_builder'
+          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 = "@b.append #{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
+            "\#{@b.format_password #{arg.arg_name.snakecase}}"
+          else
+            format_args = [arg.arg_name.snakecase, [arg.delimiter, arg.key_value_separator].compact.map { |v| "'#{v}'" }].flatten
+            "\#{@b.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
+end

data/lib/command_builder/code_generator/node_code_names.rb

@@ -0,0 +1,33 @@
+require_relative 'string_extensions'
+
+module CommandBuilder
+  module CodeGenerator
+    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
+        %w(@b) + @node.args.map { |arg| arg.arg_name.snakecase }
+      end
+
+    end
+  end
+end

data/lib/command_builder/code_generator/ruby_code_writer.rb

@@ -0,0 +1,62 @@
+module CommandBuilder
+  module CodeGenerator
+    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 }
+      end
+
+    end
+  end
+end

data/lib/command_builder/code_generator/string_extensions.rb

@@ -0,0 +1,34 @@
+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/code_generator/version.rb

@@ -0,0 +1,47 @@
+module CommandBuilder
+  module CodeGenerator
+    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
+end

data/lib/command_builder/code_generator.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: command_builder
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -16,7 +16,20 @@ email: matthew@matthewriley.name
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/command_builder/code_generator/code_generator.rb
+- lib/command_builder/code_generator/command.rb
+- lib/command_builder/code_generator/command_argument.rb
+- lib/command_builder/code_generator/command_code_names.rb
+- lib/command_builder/code_generator/command_definition.rb
+- lib/command_builder/code_generator/fragment.rb
+- lib/command_builder/code_generator/node.rb
+- lib/command_builder/code_generator/node_code_generator.rb
+- lib/command_builder/code_generator/node_code_names.rb
+- lib/command_builder/code_generator/ruby_code_writer.rb
+- lib/command_builder/code_generator/string_extensions.rb
+- lib/command_builder/code_generator/version.rb
+- lib/command_builder/code_generator.rb
 homepage: 
 licenses: []
 post_install_message: