arst 0.0.1 → 0.0.3

data/lib/arst/generator/base.rb

@@ -0,0 +1,29 @@
+module ARST
+  module Generator
+    
+    class Base
+      
+      def self.generate(node, options={})
+        new(node).generate(options)
+      end
+      
+      attr_reader :node
+      
+      def initialize(node)
+        @node = node
+      end
+      
+      def generate(options={})
+        parse_children(@node, options)
+      end
+      
+      protected
+      
+      def parse_children(node, options={})
+        raise NotImplementedError
+      end
+      
+    end
+    
+  end
+end

data/lib/arst/generator/c.rb

@@ -0,0 +1,11 @@
+require 'arst/generator/base'
+
+module ARST
+  module Generator
+    
+    class C < Base
+      
+    end
+    
+  end
+end

data/lib/arst/generator/ruby.rb

@@ -0,0 +1,164 @@
+require 'arst/generator/base'
+require 'arst/helpers'
+
+module ARST
+  module Generator
+    
+    # TODO: This class is so dirty >=) CLEANN EEETTT
+    class Ruby < Base
+      
+      def initialize(node)
+        super(node)
+        
+        @current_output = nil
+      end
+      
+      protected
+      
+      # =-=-= Hooks =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+      
+      def default_options
+        {
+          depth:             0,
+          split_files:       true,
+          indent_size:       2,
+          indent_char:       ' ',
+          newline_size:      1,
+          newline_character: "\n"
+        }
+      end
+      
+      def indent(options)
+        (options[:indent_char] * options[:indent_size]) * options[:depth]
+      end
+      
+      def newline(options)
+        newline_char = options[:newline_size] == 0 ? '; ' : options[:newline_character]
+        
+        options[:newline_character] * options[:newline_size]
+      end
+      
+      # =-=-= Parsers =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+      
+      def parse_children(node, options={})
+        options = default_options.merge( options )
+        
+        if options[:split_files]
+          @current_output = []
+          parse_children_as_multiple_files(node, options)
+        else
+          @current_output = [ { filename: filename_for_single_file(node), body: '' } ]
+          
+          parse_children_as_single_file(node, options)
+        end
+        
+        result = @current_output
+        @current_output = nil
+        
+        result
+      end
+      
+      def parse_children_as_single_file(node, options={})
+        node.children.each do |node|
+          @current_output[0][:body] << indent(options)      # TODO: DRY this up as a helper method
+          @current_output[0][:body] << code_from_node(node) # TODO: DRY this up as a helper method
+          @current_output[0][:body] << newline(options)     # TODO: DRY this up as a helper method
+          parse_children_as_single_file( node, options.merge(depth: options[:depth]+1) ) unless node.children.empty?
+          @current_output[0][:body] << "#{ indent(options) }end#{ newline(options) }" if [:module, :class].include?(node.type)
+        end
+      end
+      
+      def parse_children_as_multiple_files(node, options={})
+        options[:ancestors] = node.ancestors # The main (first) node's ancestor list
+        
+        unless [:root, :include, :extend].include?(node.type) # TODO: Hold container (class, module) and non-container (include, extend) in helper method or constant
+          body_code = parse_node_for_multiple_files(node, options)
+          body_requirements = require_statements_from_node(node)
+          body = "#{ body_requirements }#{ body_code }"
+          
+          @current_output << { filename: filename_for_split_files(node), body: body }
+        end
+        node.children.each { |child| parse_children_as_multiple_files(child, options) }
+      end
+      
+      def parse_node_for_multiple_files(node, options={})
+        output = ''
+        options[:current_ancestor_index] ||= 0
+        ancestor = options[:ancestors][ options[:current_ancestor_index] ]
+        
+        output << indent(options)          # TODO: DRY this up as a helper method
+        output << code_from_node(ancestor) # TODO: DRY this up as a helper method
+        output << newline(options)         # TODO: DRY this up as a helper method
+        
+        if options[:current_ancestor_index] == options[:ancestors].count - 1 # The first node
+          child_options = options.merge(depth: options[:depth]+1)
+          
+          ancestor.children.each do |child|
+            if [:include, :extend].include?(child.type) # TODO: Hold container (class, module) and non-container (include, extend) in helper method or constant
+              output << indent(child_options)          # TODO: DRY this up as a helper method
+              output << code_from_node(child)          # TODO: DRY this up as a helper method
+              output << newline(child_options)         # TODO: DRY this up as a helper method
+            end
+          end
+        else
+          child_options = options.merge(depth: options[:depth]+1, current_ancestor_index: options[:current_ancestor_index]+1)
+          output << parse_node_for_multiple_files( ancestor, child_options )
+        end
+        
+        output << "#{ indent(options) }end#{ newline(options) }" if [:module, :class].include?(ancestor.type)
+        
+        output
+      end
+      
+      # =-=-= Helpers =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+      
+      def filename_for_single_file(node)
+        node.children.collect(&:human_name).join('_and_') + '.rb'
+      end
+      
+      def filename_for_split_files(node)
+        node.ancestors.collect(&:human_name).join('/') + '.rb'
+      end
+      
+      def code_from_node(node)
+        case node.type
+        when :module
+          "module #{ node.name }"
+        when :class
+          code_class = "class #{ node.name }"
+          code_subclass = " < #{ node.superclass }" if node.superclass?
+          
+          "#{code_class}#{code_subclass}"
+        when :extend
+          "extend #{ node.name }"
+        when :include
+          "include #{ node.name }"
+        else
+          ""
+          # TODO: Raise ARST::Error::InvalidNodeType
+        end
+      end
+      
+      def require_statements_from_node(node)
+        # TODO: Determine scope of subclass or included/extended module
+        nodes_with_requirements = node.children.find_all do |child|
+          [:include, :extend].include?(child.type) || child.type == :class && child.superclass?
+        end
+        
+        nodes_with_requirements.unshift(node) if node.type == :class && node.superclass?
+        
+        nodes_with_requirements.collect! do |child|
+          name = child.type == :class ? child.superclass : child.name
+          ancestry = name.include?('::') ? name.split('::') : child.ancestors.collect(&:name)
+          path = ancestry.collect { |name| Helpers.underscore(name) }.join('/')
+          
+          "require '#{path}'"
+        end
+        
+        nodes_with_requirements.empty? ? nil : nodes_with_requirements.join("\n") << "\n\n"
+      end
+      
+    end
+    
+  end
+end

data/lib/arst/helpers.rb

@@ -0,0 +1,13 @@
+module ARST
+  
+  module Helpers
+    
+    def underscore(string)
+      string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+    end
+    
+    extend self
+    
+  end
+  
+end

data/lib/arst/node.rb

@@ -0,0 +1,25 @@
+require 'arst/node/root'
+require 'arst/node/module'
+require 'arst/node/class'
+require 'arst/node/include'
+require 'arst/node/extend'
+
+module ARST
+  
+  module Node
+    
+    # TODO: Rename to something more specific... from_raw_tree?
+    def self.from_options(options)
+      case options[:type]
+      when 'module'  then Node::Module.new(options)
+      when 'class'   then Node::Class.new(options)
+      when 'extend'  then Node::Extend.new(options)
+      when 'include' then Node::Include.new(options)
+      else
+        # TODO: Raise ARST::Error::InvalidNodeType
+      end
+    end
+    
+  end
+  
+end

data/lib/arst/node/base.rb

@@ -0,0 +1,39 @@
+require 'arst/helpers'
+
+module ARST
+  module Node
+    
+    class Base
+      
+      attr_reader :parent, :children
+      
+      def initialize(options={})
+        # TODO: Validate keys
+        options = default_options.merge(options)
+        
+        @parent, @children = options.values_at(:parent, :children)
+        @children.collect! { |child_options| Node.from_options( child_options.merge(parent: self) ) }
+      end
+      
+      def ancestors
+        return [] if parent.nil?
+        
+        ( parent.ancestors || [] ) + [self]
+      end
+      
+      def type
+        @type ||= ARST::Helpers.underscore(self.class.to_s.split(/::/).last).to_sym
+      end
+      
+      protected
+      
+      def default_options
+        {
+          children: []
+        }
+      end
+      
+    end
+    
+  end
+end

data/lib/arst/node/class.rb

@@ -0,0 +1,32 @@
+require 'arst/node/base'
+require 'arst/node/namable'
+
+module ARST
+  module Node
+    
+    class Class < Base
+      
+      include Namable
+      
+      attr_reader :superclass
+      
+      def initialize(options={})
+        super(options)
+        
+        # TODO: Validate keys
+        self.superclass = options[:superclass]
+      end
+      
+      def superclass=(superclass)
+        # TODO: Sanitize `superclass` given
+        @superclass = superclass.to_s unless superclass.nil?
+      end
+      
+      def superclass?
+        !superclass.nil?
+      end
+      
+    end
+    
+  end
+end

data/lib/arst/node/extend.rb

@@ -0,0 +1,14 @@
+require 'arst/node/base'
+require 'arst/node/namable'
+
+module ARST
+  module Node
+    
+    class Extend < Base
+      
+      include Namable
+      
+    end
+    
+  end
+end

data/lib/arst/node/include.rb

@@ -0,0 +1,14 @@
+require 'arst/node/base'
+require 'arst/node/namable'
+
+module ARST
+  module Node
+    
+    class Include < Base
+      
+      include Namable
+      
+    end
+    
+  end
+end

data/lib/arst/node/module.rb

@@ -0,0 +1,14 @@
+require 'arst/node/base'
+require 'arst/node/namable'
+
+module ARST
+  module Node
+    
+    class Module < Base
+      
+      include Namable
+      
+    end
+    
+  end
+end

data/lib/arst/node/namable.rb

@@ -0,0 +1,26 @@
+module ARST
+  module Node
+    
+    module Namable
+      
+      attr_reader :name
+      
+      def initialize(options={})
+        super(options)
+        
+        # TODO: Validate keys
+        self.name = options[:name]
+      end
+      
+      def name=(name)
+        @name = name.to_s # TODO: Sanitize
+      end
+      
+      def human_name
+        ARST::Helpers.underscore(name)
+      end
+      
+    end
+    
+  end
+end

data/lib/arst/node/root.rb

@@ -0,0 +1,11 @@
+require 'arst/node/base'
+
+module ARST
+  module Node
+    
+    class Root < Base
+      
+    end
+    
+  end
+end

data/lib/arst/parser.rb

@@ -0,0 +1,64 @@
+require 'parslet'
+require 'arst/node'
+
+module ARST
+  
+  # The parser for ARST.
+  class Parser < Parslet::Parser
+    
+    def self.parse(input, options={})
+      new.parse(input, options)
+    end
+    
+    def parse(input, options={})
+      tree = super(input)
+      
+      options[:raw] ? tree : Node::Root.new(tree)
+    end
+    
+    def indent(depth)
+      str('  ' * depth)
+    end
+    
+    rule(:space)   { match('[\t\s]') }
+    rule(:spaces)  { space.repeat(1) }
+    rule(:newline) { match('\n') }
+    
+    rule :constant do
+      match('[A-Z]') >> ( match('[A-Za-z0-9]') | str('::') ).repeat(1) # TODO: Cannot end with '::'
+    end
+    
+    rule :module_keyword do
+      str('module').as(:type) >> spaces >> constant.as(:name)
+    end
+    
+    rule :class_keyword do
+      str('class').as(:type) >> spaces >> constant.as(:name) >>
+      ( spaces >> str('<') >> spaces >> constant.as(:superclass) ).maybe
+    end
+    
+    rule :include_keyword do
+      str('include').as(:type) >> space >> constant.as(:name)
+    end
+    
+    rule :extend_keyword do
+      str('extend').as(:type) >> space >> constant.as(:name)
+    end
+    
+    def node(depth)
+      indent(depth) >> 
+      (
+        ( class_keyword | module_keyword ) >> newline.maybe >>
+        dynamic { |soutce, context| node(depth+1).repeat(0) }.as(:children) |
+        ( include_keyword | extend_keyword ) >> newline.maybe |
+        newline
+      )
+    end 
+    
+    rule(:document) { node(0).repeat.as(:children) }
+    
+    root :document
+    
+  end
+  
+end