aws-sdk-code-generator 0.1.0.pre

data/lib/aws-sdk-code-generator/dsl/block_param.rb

@@ -0,0 +1,11 @@
+module AwsSdkCodeGenerator
+  module Dsl
+    class BlockParam < Param
+
+      def initialize(options = {})
+        super('&block')
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/class.rb

@@ -0,0 +1,27 @@
+module AwsSdkCodeGenerator
+  module Dsl
+    class Class < Dsl::Module
+
+      # @option options [String, nil] :extends (nil)
+      def initialize(name, options = {}, &block)
+        super(name, options, &block)
+        @extends = options.fetch(:extends, nil)
+      end
+
+      def open_module
+        lines = ["class #{@name}"]
+        if @extends
+          extends = @extends.lines.to_a
+          lines[-1] = "#{lines[-1]} < #{extends[0].rstrip}"
+          extends[1..-1].each do |line|
+            lines << line.rstrip
+          end
+          lines
+        else
+          ["class #{@name}"]
+        end
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/code_literal.rb

@@ -0,0 +1,66 @@
+module AwsSdkCodeGenerator
+  module Dsl
+    class CodeLiteral
+
+      include Dsl::CodeObject
+
+      # @param [String] code
+      # @option options [Integer] :nesting (0)
+      def initialize(code = nil, options = {}, &block)
+        @code_objects = []
+        @nesting = options.fetch(:nesting, 0)
+        append(code) if code
+        yield(self) if block
+      end
+
+      attr_accessor :nesting
+
+      # @param [String, CodeLiteral]
+      def <<(code)
+        if CodeLiteral === code || String === code
+          @code_objects << [@nesting, code]
+        else
+          msg = "expected String or CodeLiteral, got #{code.class}"
+          raise ArgumentError, msg
+        end
+      end
+      alias :append :<<
+
+      def newline
+        @code_objects << [@nesting, :newline]
+      end
+
+      def indent(code = nil, &block)
+        @nesting += 1
+        code = CodeLiteral.new(code) unless CodeLiteral === code
+        append(code)
+        yield(code) if block
+        @nesting -= 1
+        code
+      end
+
+      def lines(pad = '')
+        lines = []
+        @code_objects.each do |i, code_obj|
+          case code_obj
+          when :newline
+            lines << :newline
+          when String
+            code_obj.lines.each do |line|
+              line = line.rstrip
+              if line == ''
+                lines << :newline
+              else
+                lines << "#{pad}#{'  ' * i}#{line}"
+              end
+            end
+          when CodeLiteral
+            lines.concat(code_obj.lines(pad + ('  ' * i)))
+          end
+        end
+        lines
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/code_object.rb

@@ -0,0 +1,33 @@
+require 'set'
+
+module AwsSdkCodeGenerator
+  module Dsl
+    # @api private
+    module CodeObject
+
+      def to_s
+        format(lines)
+      end
+
+      private
+
+      def underscore(str)
+        Underscore.underscore(str)
+      end
+
+      def format(lines, nesting = 0)
+        i = '  ' * nesting
+        lines.inject([]) do |code, obj|
+          case obj
+          when :newline then code << "\n"
+          when String then code << "#{i}#{obj}\n"
+          when CodeObject then code.concat(obj.lines)
+          when Array, Enumerator then code << format(obj, nesting + 1)
+          else raise ArgumentError, "got #{obj.class}"
+          end
+        end.join
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/docstring.rb

@@ -0,0 +1,36 @@
+module AwsSdkCodeGenerator
+  module Dsl
+    # @api private
+    class Docstring
+
+      include Dsl::CodeObject
+
+      # @param [String, nil]
+      def initialize(docstring = nil, &block)
+        @lines = []
+        append(docstring)
+        yield(self) if block
+      end
+
+      def append(docstring)
+        @lines.concat(docstring.to_s.rstrip.lines.map do |line|
+          if line == "\n"
+            "#"
+          else
+            "# #{line.rstrip}"
+          end
+        end)
+      end
+      alias :<< :append
+
+      # @return [Array<String>]
+      attr_reader :lines
+
+      # @return [Boolean]
+      def empty?
+        @lines.empty?
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/eigenclass.rb

@@ -0,0 +1,15 @@
+module AwsSdkCodeGenerator
+  module Dsl
+    class Eigenclass < Dsl::Module
+
+      def initialize(&block)
+        super('self', &block)
+      end
+
+      def open_module
+        ["class << self"]
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/extend_statement.rb

@@ -0,0 +1,12 @@
+module AwsSdkCodeGenerator
+  module Dsl
+
+    class ExtendStatement < IncludeStatement
+
+      def lines
+        ["extend #{@module_name}"]
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/formatter.rb

@@ -0,0 +1,25 @@
+module AwsSdkCodeGenerator
+  module Dsl
+    class Formatter
+
+      def initialize
+        @indent = '  '
+      end
+
+      def format(lines, nesting:0)
+        i = @indent * nesting
+        lines.inject([]) do |code, section|
+          case section
+          when "\n"       then code << "\n" # do not indent blank lines
+          when CodeObject then code.concat(section.lines)
+          when String     then code << "#{i}#{section}"
+          when Array      then code << format(section, nesting:nesting + 1)
+          else
+            raise ArgumentError, "got #{section.class}"
+          end
+        end.join
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/include_statement.rb

@@ -0,0 +1,17 @@
+module AwsSdkCodeGenerator
+  module Dsl
+    class IncludeStatement
+
+      include Dsl::CodeObject
+
+      def initialize(module_name)
+        @module_name = module_name
+      end
+
+      def lines
+        ["include #{@module_name}"]
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/main.rb

@@ -0,0 +1,105 @@
+module AwsSdkCodeGenerator
+  module Dsl
+    class Main
+
+      include Dsl::CodeObject
+
+      # @option options [Main, Module] :parent (nil)
+      def initialize(options = {}, &block)
+        @comments = Docstring.new(nil)
+        @top_content = []
+        @code_objects = []
+        @parent = options.fetch(:parent, nil)
+        yield(self) if block
+      end
+
+      # @return [nil, CodeObject]
+      attr_accessor :parent
+
+      # @return [nil, CodeObject]
+      def root
+        root = self
+        root = root.parent while root && root.parent
+        root
+      end
+
+      def add(*code_objects)
+        code_objects.each do |code_obj|
+          @code_objects << code_obj unless code_obj.nil?
+        end
+      end
+
+      def code(code = nil, &block)
+        @code_objects << CodeLiteral.new(code, &block)
+      end
+
+      def comments(docstring)
+        @comments = Docstring.new(docstring)
+      end
+
+      def include_module(module_name)
+        add(IncludeStatement.new(module_name))
+      end
+      alias :include :include_module
+
+      def extend_module(module_name)
+        add(ExtendStatement.new(module_name))
+      end
+      alias :extend :extend_module
+
+      def require_statement(path)
+        @top_content << "require '#{path}'"
+      end
+      alias require require_statement
+
+      # Allows inserting top-of document content.
+      def top(string)
+        root.instance_variable_get("@top_content") << string
+      end
+
+      def require_relative(path)
+        @top_content << "require_relative '#{path}'"
+      end
+
+      def method(name, options = {}, &block)
+        m = Dsl::Method.new(name, options)
+        yield(m) if block
+        add(m)
+      end
+
+      def module(name, &block)
+        m = Dsl::Module.new(name, parent: self)
+        yield(m) if block
+        add(m)
+        m
+      end
+
+      def class(name, options = {}, &block)
+        c = Dsl::Class.new(name, options.merge(parent: self))
+        yield(c) if block
+        add(c)
+        c
+      end
+
+      def lines
+
+        lines = []
+
+        lines.concat(@comments.lines)
+        lines << :newline unless @comments.empty?
+
+        @top_content.each do |statement|
+          lines << statement
+        end
+        lines << :newline unless @top_content.empty?
+
+        @code_objects.each.with_index do |code_obj, n|
+          lines.concat(code_obj.lines)
+          lines << :newline unless n == @code_objects.size - 1
+        end
+        lines
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-code-generator/dsl/method.rb

@@ -0,0 +1,108 @@
+module AwsSdkCodeGenerator
+  module Dsl
+    class Method
+
+      include Dsl::CodeObject
+
+      # @option options [Symbol] :access (:public)
+      # @option options [String, nil] :docstring (nil)
+      def initialize(name, options = {}, &block)
+        @name = name.to_s
+        @access = options.fetch(:access, :public)
+        @code_objects = []
+        @params = []
+        @option_tags = []
+        @return_tags = []
+        @aliases = []
+        @docstring = Dsl::Docstring.new(options.fetch(:docstring, nil))
+        @api_private = options.fetch(:api_private, false)
+        yield(self) if block
+      end
+
+      attr_reader :name
+
+      attr_reader :access
+
+      attr_reader :aliases
+
+      def param(name, options = {})
+        @params << Param.new(name, options)
+      end
+
+      def option(options)
+        @option_tags << OptionTag.new(options)
+      end
+
+      def returns(type, options = {})
+        @return_tags << ReturnTag.new(options.merge(type:type))
+      end
+
+      def add(*code_objects)
+        @code_objects.concat(code_objects)
+      end
+
+      def code(code = nil, &block)
+        @code_objects << CodeLiteral.new(code, &block)
+      end
+
+      def empty?
+        @code_objects.empty?
+      end
+
+      def docstring(docstring = nil, &block)
+        @docstring.append(docstring)
+        yield(@docstring) if block
+        @docstring
+      end
+
+      def block_param
+        @params << BlockParam.new
+      end
+
+      def alias_as(other_name)
+        @aliases << other_name.to_s
+      end
+
+      def lines
+        code = []
+        code.concat(yard_docs)
+        code << method_signature
+        code << method_body
+        code << method_end
+        code.concat(@aliases.map { |a| "alias :#{a} :#{@name}" })
+        code
+      end
+
+      private
+
+      def yard_docs
+        docs = []
+        docs.concat(@docstring.lines)
+        tags = []
+        tags.concat(ParamList.new(@params).tags)
+        tags.concat(@option_tags)
+        tags.concat(@return_tags)
+        tags << "# @api private" if @api_private
+        tags.each.with_index do |tag, n|
+          docs.concat(tag.lines.to_a)
+        end
+        docs.compact
+      end
+
+      def method_signature
+        "def #{@name}#{ParamList.new(@params).signature}"
+      end
+
+      def method_body
+        @code_objects.inject([]) do |lines, code_obj|
+          lines.concat(code_obj.lines)
+        end
+      end
+
+      def method_end
+        "end"
+      end
+
+    end
+  end
+end