arst 0.0.1 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14e94c66c9581aa1b34916e7d471a03d72ae29bd
+  data.tar.gz: 26ad558b52a7621a317545033aa039b9b5ce50b2
+SHA512:
+  metadata.gz: 049fac53c834139edd2bb171b97cd526498d4c5bf8241ba3793998d5f1d8ccd518c6fb5a6e82be2a30efbe4df96e4fe7bc6bf941ee2b9b101ec23d169086fd50
+  data.tar.gz: fe66efb68766698e169712774342a3090af78423e29cf9cff2e8b250a47ebedb82e690a22bbd2f57cdd517965700a11f1058fd98eb78b0a2d2b8e46c3c9adc4a

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
+gem 'pry'
+
 gemspec

data/Gemfile.lock

@@ -1,9 +1,10 @@
 PATH
   remote: .
   specs:
-    arst (0.0.1)
+    arst (0.0.3)
       active_support (~> 3.0.0)
       parslet (~> 1.5.0)
+      rake (~> 10.0.0)
       version (~> 1.0.0)
 
 GEM
@@ -40,11 +41,17 @@ GEM
       coderay (~> 1.0.5)
       method_source (~> 0.8)
       slop (~> 3.4)
+    pry (0.9.12-x86-mingw32)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+      win32console (~> 1.3)
     rake (10.0.4)
     rb-fsevent (0.9.3)
     slop (3.4.4)
     thor (0.18.1)
     version (1.0.0)
+    win32console (1.3.2-x86-mingw32)
 
 PLATFORMS
   ruby
@@ -56,5 +63,5 @@ DEPENDENCIES
   cocaine (~> 0.5.0)
   guard-bundler (~> 1.0.0)
   guard-shell (~> 0.5.0)
-  rake (~> 10.0.0)
+  pry
   rb-fsevent (~> 0.9.0)

data/README.md

@@ -1,11 +1,12 @@
 # ARST
 
-Abstract Ruby Syntax Tree (ARST) is a high-level language syntax denoting the object domain of a Ruby project.
+Abstract Ruby Syntax Tree (ARST) is a high-level language syntax denoting the object domain of a Ruby project and a polyglot source code generator.
 
 ARST can be used to generate:
 
-* Pure Ruby
+* Pure Ruby code
 * C Ruby extensions
+* Java Ruby extensions
 * Test::Unit, MiniTest::Unit, MiniTest::Spec, or RSpec tests
 * GraphViz graphs
 * Custom output
@@ -18,15 +19,15 @@ ARST files can also be generated from existing projects which allows:
 
 Integrations:
 
-* [Rake](https://github.com/RyanScottLewis/rake-arst)
+* Rake (baked in)
 * [Thor](https://github.com/RyanScottLewis/thor-arst)
 * [Guard](https://github.com/RyanScottLewis/guard-arst)
 
 Generators:
 
-* ARST::Generator::Ruby (baked into this gem)
-* ARST::Generator::CRuby (baked into this gem)
-* [ARST::Generator::JRuby](https://github.com/RyanScottLewis/arst-generator-jruby)
+* ARST::Generator::Ruby (baked in)
+* ARST::Generator::C (baked in)
+* [ARST::Generator::Java](https://github.com/RyanScottLewis/arst-generator-java)
 * [ARST::Generator::Test::Unit](https://github.com/RyanScottLewis/arst-generator-test-unit)
 * [ARST::Generator::MiniTest::Unit](https://github.com/RyanScottLewis/arst-generator-minitest-unit)
 * [ARST::Generator::MiniTest::Spec](https://github.com/RyanScottLewis/arst-generator-minitest-spec)
@@ -53,6 +54,9 @@ This means that most syntax highlighters for Ruby will also work for ARST.
 * `class ClassName < SuperClassName`
 * `include ModuleName`
 * `extend ModuleName`
+
+**Not Yet Implemented:**
+
 * `def instance_method(arg1, *other_args)` (and anything else accepted method arguments in Ruby's syntax)
 * `def self.class_method(arg1, opts={})` (and anything else accepted method arguments in Ruby's syntax)
 
@@ -61,42 +65,247 @@ This means that most syntax highlighters for Ruby will also work for ARST.
 ARST is an indentation-sensitive syntax meaning that the following are **not** equivalent:
 
 <table width="100%"><tr><td>
-```rb
+<pre>
 module Foo
   module Bar
-```
+</pre>
 </td><td>
-```rb
+<pre>
 module Foo
 module Bar
-```
-</td></tr><table>
+</pre>
+</td></tr></table>
   
-When interpreting the ARST syntax, the parser accepts any number of identical sequential whitespace characters
-at the starst of a line as an "indentation step".  
-Valid whitespace characters are the space (` `) and tab (`\t`) characters.
+When interpreting the ARST syntax, the parser accepts 2 identical sequential whitespace characters
+at the start of a line as an "indentation step".  
+Valid whitespace characters are the space and tab characters.
 
 Once the first indentation step is found while parsing, all subsequent indentation steps must contain the same
 amount of whitespace characters as the first step:
 
 <table width="100%"><tr><td>
-**Valid**
-```rb
+<b>Valid</b>
+<pre>
 module Foo
   module Bar
     module Baz
-```
+</pre>
 </td><td>
-**Invalid**
-```rb
+<b>Invalid</b>
+<pre>
 module Foo
   module Bar
          module Baz
-```
-</td></tr><table>
+</pre>
+</td></tr></table>
 
 ## Usage
 
+### Constructing ARST file
+
+The first step is to create an `.arst` file within your project. There is no convention as to where to place this file,
+but I like to put it in the root directory and name it the same as my project, like a `.gemspec` file.
+
+`stupid_record.arst`
+
+```rb
+module StupidModel
+  module Validations
+  module Callbacks
+  module Serialization
+    module ClassMethods
+    module InstanceMethods
+  class Base
+    extend Callbacks
+    include Validations
+    include Serialization
+module StupidRecord
+  module Persistence
+  class Base < StupidModel::Base
+    include Persistence
+```
+
+### Setup Rake task
+
+`Rakefile`
+
+```rb
+require 'arst/rake_task'
+
+ARST::RakeTask.new do |t|
+  t.generate(:ruby, input_path: 'stupid_record.arst', split_files: false, output_path: 'lib/stupid_record.rb')
+end
+```
+
+### Generate your code
+
+### Ruby
+
+Running `rake arst:ruby` will generate the following Ruby code in the `lib/stupid_record.rb` file:
+
+```rb
+module StupidModel
+  module Validations
+  end
+  module Callbacks
+  end
+  module Serialization
+    module ClassMethods
+    end
+    module InstanceMethods
+    end
+  end
+  class Base
+    extend Callbacks
+    include Validations
+    include Serialization
+  end
+end
+module StupidRecord
+  module Persistence
+  end
+  class Base < StupidModel::Base
+    include Persistence
+  end
+end
+```
+
+Tasty! We turned 14 lines into 24 lines, like magic! But wait.. this isn't how conventional Ruby projects file hierarchies
+are structured. The above is great for generating simple example Ruby files, but what about bootstrapping an entire project?
+
+Let's refactor our Rake task:
+
+`Rakefile`
+
+```rb
+require 'arst/rake_task'
+
+ARST::RakeTask.new do |t|
+  t.add_generator type: :ruby, input_path: 'stupid_record.arst', output_path: 'stupid_record/lib'
+end
+```
+
+> Note: The `:split_files` option is `true` and the `output_path` option is `'lib'` by default in the Ruby generator.  
+> Each generator has it's own set of options.
+
+Now, when we run the `rake arst:generate` task to generate our code, the project is bootstrapped in a more conventional manner:
+
+`lib/stupid_model.rb`
+
+```rb
+require 'stupid_model/base'
+
+module StupidModel
+end
+```
+
+`lib/stupid_model/validations.rb`
+
+```rb
+module StupidModel
+  module Validations
+  end
+end
+```
+
+`lib/stupid_model/callbacks.rb`
+
+```rb
+module StupidModel
+  module Callbacks
+  end
+end
+```
+
+`lib/stupid_model/serialization.rb`
+
+```rb
+require 'stupid_model/serialization/class_methods'
+require 'stupid_model/serialization/instance_methods'
+
+module StupidModel
+  module Serialization
+  end
+end
+```
+
+`lib/stupid_model/serialization/class_methods.rb`
+
+```rb
+module StupidModel
+  module Serialization
+    module ClassMethods
+    end
+  end
+end
+```
+
+`lib/stupid_model/serialization/instance_methods.rb`
+
+```rb
+module StupidModel
+  module Serialization
+    module InstanceMethods
+    end
+  end
+end
+```
+
+`lib/stupid_model/base.rb`
+
+```rb
+require 'stupid_model/validations'
+require 'stupid_model/callbacks'
+require 'stupid_model/serialization'
+
+module StupidModel
+  class Base
+    extend Callbacks
+    include Validations
+    include Serialization
+  end
+end
+```
+
+`lib/stupid_record.rb`
+
+```rb
+require 'stupid_record/base'
+
+module StupidRecord
+end
+```
+
+`lib/stupid_record/persistence.rb`
+
+```rb
+module StupidRecord
+  module Persistence
+  end
+end
+```
+
+`lib/stupid_record/base.rb`
+
+```rb
+require 'stupid_model/base'
+require 'stupid_record/persistence'
+
+module StupidRecord
+  class Base < StupidModel::Base
+    include Persistence
+  end
+end
+```
+
+Holy Moses! Now we're saving some typing!  
+This may not be exactly the code you were looking to generate, but it's close enough to start working quickly.
+
+The ARST Ruby generator attempts to be as smart about adding `require` statements as possible.
+
+> Warning: When we generate the files, they are OVERWRITTEN. Meaning you WILL LOSE CODE if the file already exists.  
+> There are plans in the *far* future for generating only missing nodes in the ARST and removing code that is NOT within the ARST.
+
 ## Copyright
 
 Copyright © 2013 Ryan Scott Lewis <ryan@rynet.us>.

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.3

data/arst.gemspec

@@ -11,15 +11,14 @@ Gem::Specification.new do |s|
   # Dependencies
   s.add_dependency 'active_support', '~> 3.0.0'
   s.add_dependency 'parslet',        '~> 1.5.0'
+  s.add_dependency 'rake',           '~> 10.0.0'
   s.add_dependency 'version',        '~> 1.0.0'
   # s.add_dependency 'polyglot',       '~> 0.3.0'
   s.add_development_dependency 'awesome_print', '~> 1.1.0'
   s.add_development_dependency 'cocaine',       '~> 0.5.0'
   s.add_development_dependency 'guard-bundler', '~> 1.0.0'
   s.add_development_dependency 'guard-shell',   '~> 0.5.0'
-  s.add_development_dependency 'rake',          '~> 10.0.0'
   s.add_development_dependency 'rb-fsevent',    '~> 0.9.0'
-
   
   # Pragmatically set variables
   s.homepage      = "http://github.com/RyanScottLewis/#{s.name}"
@@ -27,7 +26,7 @@ Gem::Specification.new do |s|
   s.description   = s.summary
   s.name          = Pathname.new(__FILE__).basename('.gemspec').to_s
   s.require_paths = ['lib']
-  s.files         = Dir['{{Rake,Gem}file{.lock,},README*,VERSION,LICENSE,*.gemspec,lib/morris-rails{.rb,**/*.rb},spec/**/*.rb,app/**/*.*}']
+  s.files         = Dir['{{Rake,Gem}file{.lock,},README*,VERSION,LICENSE,*.gemspec,{lib,bin,examples,spec,test}/**/*}']
   s.test_files    = Dir['{examples,spec,test}/**/*']
   
 end

data/examples/Rakefile

@@ -0,0 +1,5 @@
+require_relative '../lib/arst/rake_task'
+
+ARST::RakeTask.new do |t|
+  t.add_generator type: :ruby, input_path: 'simple.arst', output_path: 'simple'
+end

data/examples/simple.arst

@@ -0,0 +1,16 @@
+module StupidModel
+  module Validations
+  module Callbacks
+  module Serialization
+    module ClassMethods
+    module InstanceMethods
+  module OptionalMethods
+  class Base
+    extend Callbacks
+    include Validations
+    include Serialization
+module StupidRecord
+  module Persistence
+  class Base < StupidModel::Base
+    include Persistence
+    include StupidModel::OptionalMethods

data/lib/arst.rb

@@ -0,0 +1,8 @@
+require 'version'
+require 'arst/parser'
+require 'arst/generator'
+
+# Abstract Ruby Syntax Tree (ARST) is a high-level language syntax denoting the object domain of a Ruby project and a polyglot source code generator.
+module ARST
+  is_versioned
+end

data/lib/arst/generator.rb

@@ -0,0 +1,14 @@
+require 'arst/generator/ruby'
+require 'arst/generator/c'
+
+module ARST
+  
+  module Generator
+    
+    def self.generate(generator_type, node, options={})
+      const_get(generator_type.to_s.capitalize).generate(node, options)
+    end
+    
+  end
+  
+end

data/lib/arst/generator/arst.rb

@@ -0,0 +1,37 @@
+require 'arst/generator/base'
+
+module ARST
+  module Generator
+    
+    class ARST < Base
+      
+      protected
+      
+      def parse_children(node, options={})
+        output = ''
+        
+        node[:children].each do |node|
+          output << (options[:indent_char] * options[:indent_size]) * options[:depth]
+          
+          if node[:module]
+            output << "module #{ node[:module] }"
+          elsif node[:class]
+            output << "class #{ node[:class] }"
+            output << " < #{ node[:superclass] }" if node[:superclass]
+          elsif node[:include]
+            output << "include #{ node[:include] }"
+          elsif node[:extend]
+            output << "extend #{ node[:extend] }"
+          end
+          
+          output << "\n"
+          output << parse_children( node, options.merge(depth: options[:depth]+1) ) if node.has_key?(:children)
+        end
+        
+        output
+      end
+      
+    end
+    
+  end
+end