jets 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea729cf2c680bcafc1d8bafec528b5d12297950d
-  data.tar.gz: 907b75758d90f747f01ad72e603f2f3259c3044a
+  metadata.gz: 1960e461a36b47bd872fe91a5c58569569c4a1e9
+  data.tar.gz: cb9d30dfd4cf492849a3927afcaf6d4297defa90
 SHA512:
-  metadata.gz: cc68a50b42bc8f9188d4393a3cba1b4f24dedf69f38ee30dbb5c523481c561c0d4f83e96fd867119c14d15b3c7f4d9d677a0a412d937850fe96c0b4ce553525b
-  data.tar.gz: 148b5348a24575a33fd362940fc3e5b821a14342471e8b38e6463811bffc28aed52f5a8946cb10d820a8c8cd9b62b068bbff29890af3c88f6c9037e5c73738c9
+  metadata.gz: 65362fbb12abc9d06b55af768278ecaaeebcd5467d444c97a2de4b733cf802daa078f81b3d493e1ca383e7e8a858aa5fd54e1da11e28bc2dcd88e112df56b608
+  data.tar.gz: c6083ef3edcc89f4354d3f84b4cd2b8c079fcad914164f9c1862d8055f10df4fdc8d9c489e54141b1d9d51ca85d1a69c09e054782e14595f8b8d65ae7f26fed0

data/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+This project *tries* to adhere to [Semantic Versioning](http://semver.org/), even before v1.0.
+
+## [0.1.2]
+- Fix bundled gems.

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    jets (0.2.0)
+      activesupport
+      colorize
+      hashie
+      thor
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    byebug (9.1.0)
+    codeclimate-test-reporter (1.0.8)
+      simplecov (<= 0.13)
+    colorize (0.8.1)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
+    docile (1.1.5)
+    hashie (3.5.6)
+    i18n (0.9.0)
+      concurrent-ruby (~> 1.0)
+    json (2.1.0)
+    minitest (5.10.3)
+    rake (12.2.1)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+    simplecov (0.13.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    thor (0.20.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.3)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  byebug
+  codeclimate-test-reporter
+  jets!
+  rake
+  rspec

data/Guardfile

@@ -1,12 +1,22 @@
-guard "rspec" do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})      { "spec/jets_spec.rb" }
-  watch(%r{^lib/jets/(.+)\.rb$})  { "spec/jets_spec.rb" }
-  watch("spec/spec_helper.rb")   { "spec/jets_spec.rb" }
-  watch(%r{^lib/jets/(.+)\.rb$})   { |m| "spec/lib/#{m[1]}_spec.rb" }
-end
-
-guard "bundler" do
+guard "bundler", cmd: "bundle" do
   watch("Gemfile")
   watch(/^.+\.gemspec/)
 end
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  puts "ruby.lib_files #{ruby.lib_files.inspect}"
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
+end

data/README.md

@@ -12,28 +12,21 @@ TODO: Write a gem description
 
 Add this line to your application's Gemfile:
 
-    gem "jets"
+```sh
+gem "jets"
+```
 
 And then execute:
 
-    $ bundle
+```sh
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install jets
-
-## Usage
-
-<pre>
-git clone https://github.com/tongueroo/jets.git
-mv jets <project_name>
-cd <project_name>
-rake rename
-rm -rf .git
-git init
-git add .
-git commit -m "init commit"
-</pre>
+```
+$ gem install jets
+```
 
 ## Contributing
 

data/jets.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |spec|
   spec.version       = Jets::VERSION
   spec.authors       = ["Tung Nguyen"]
   spec.email         = ["tongueroo@gmail.com"]
-  spec.description   = %q{}
-  spec.summary       = %q{}
-  spec.homepage      = ""
+  spec.description   = %q{Test}
+  spec.summary       = %q{Test}
+  spec.homepage      = "https://github.com/tongueroo/jets"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -21,10 +21,14 @@ Gem::Specification.new do |spec|
   spec.add_dependency "thor"
   spec.add_dependency "hashie"
   spec.add_dependency "colorize"
+  spec.add_dependency "activesupport"
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "byebug"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "guard"
-  spec.add_development_dependency "guard-bundler"
-  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "rspec"
+  # ruby_dep-1.5.0 requires ruby version >= 2.2.5, which is incompatible with the current version, ruby 2.2.2p95
+  # spec.add_development_dependency "guard"
+  # spec.add_development_dependency "guard-bundler"
+  # spec.add_development_dependency "guard-rspec"
 end

data/lib/jets.rb

@@ -1,7 +1,18 @@
 $:.unshift(File.expand_path("../", __FILE__))
 require "jets/version"
+require "active_support/core_ext/string"
+require "colorize"
+require 'pp'
 
 module Jets
+  autoload :Util, "jets/util"
   autoload :Command, "jets/command"
   autoload :CLI, "jets/cli"
+  autoload :Build, 'jets/build'
+  autoload :Process, 'jets/process'
+  autoload :BaseController, 'jets/base_controller'
+  autoload :Project, 'jets/project'
+  autoload :Cfn, 'jets/cfn'
+
+  extend Util
 end

data/lib/jets/base_controller.rb

@@ -0,0 +1,54 @@
+require 'json'
+
+module Jets
+  class BaseController
+    attr_reader :event, :context
+    def initialize(event, context)
+      @event = event
+      @context = context
+    end
+
+    # The public methods defined in the user's custom class will become
+    # lambda functions.
+    # Returns Example:
+    #   ["FakeController#handler1", "FakeController#handler2"]
+    def lambda_functions
+      # public_instance_methods(false) - to not include inherited methods
+      self.class.public_instance_methods(false) - Object.public_instance_methods
+    end
+
+    def self.lambda_functions
+      new(nil, nil).lambda_functions
+    end
+
+  private
+    def render(options={})
+      # render json: {"mytestdata": "value1"}, status: 200, headers: {...}
+      if options.has_key?(:json)
+        # Transform the structure to Lambda Proxy structure
+        # {statusCode: ..., body: ..., headers: }
+        status = options.delete(:status)
+        body = options.delete(:json)
+        result = options.merge(
+          statusCode: status,
+          body: body
+        )
+      # render text: "text"
+      elsif options.has_key?(:text)
+        result = options.delete(:text)
+      else
+        raise "Unsupported render option. Only :text and :json supported.  options #{options.inspect}"
+      end
+
+      result
+    end
+
+    # API Gateway LAMBDA_PROXY wraps the event in its own structure.
+    # We unwrap the "body" before sending it back
+    # For regular Lambda function calls, no need to unwrap but need to
+    # transform it to a string with JSON.dump.
+    def normalize_event_body(event)
+      body = event.has_key?("body") ? event["body"] : JSON.dump(event)
+    end
+  end
+end

data/lib/jets/build.rb

@@ -0,0 +1,46 @@
+class Jets::Build
+  autoload :LambdaDeducer, "jets/build/lambda_deducer"
+  autoload :HandlerGenerator, "jets/build/handler_generator"
+  autoload :TravelingRuby, "jets/build/traveling_ruby"
+
+  def initialize(options)
+    @options = options
+  end
+
+  def run
+    puts "Building project for Lambda..."
+    build
+  end
+
+  def build
+    puts "Building node shim handlers..."
+    controller_paths.each do |path|
+      deducer = LambdaDeducer.new(path)
+      generator = HandlerGenerator.new(deducer.class_name, *deducer.functions)
+      generator.run
+    end
+
+    puts "Building TravelingRuby..."
+    TravelingRuby.new.build unless @options[:noop]
+
+    puts "Building Lambda functions as CloudFormation templates"
+
+  end
+
+  def controller_paths
+    paths = []
+    expression = "#{Jets.root}app/controllers/**/*.rb"
+    Dir.glob(expression).each do |path|
+      next unless File.file?(path)
+      next if path.include?("application_controller.rb")
+
+      paths << relative_path(path)
+    end
+    paths
+  end
+
+  # Rids of the Jets.root at beginning
+  def relative_path(path)
+    path.sub(Jets.root, '')
+  end
+end

data/lib/jets/build/handler_generator.rb

@@ -0,0 +1,46 @@
+require "fileutils"
+require "erb"
+
+class Jets::Build
+  class HandlerGenerator
+    # Jets::Build::HandlerGenerator.new(
+    #   "PostsController",
+    #   :create, :update
+    # )
+    def initialize(class_name, *methods)
+      @class_name = class_name
+      @methods = methods
+    end
+
+    def run
+      js_path = "#{Jets.root}handlers/#{process_type.pluralize}/#{module_name}.js"
+      FileUtils.mkdir_p(File.dirname(js_path))
+
+      template_path = File.expand_path('../templates/handler.js', __FILE__)
+      template = IO.read(template_path)
+
+      # Set used ERB variables:
+      @process_type = process_type
+      @functions = @methods.map do |m|
+        {
+          name: m,
+          handler: handler(m)
+        }
+      end
+      result = ERB.new(template, nil, "-").result(binding)
+      IO.write(js_path, result)
+    end
+
+    def process_type
+      @class_name.underscore.split('_').last
+    end
+
+    def handler(method)
+      "handlers/#{process_type.pluralize}/#{module_name}.#{method}"
+    end
+
+    def module_name
+      @class_name.sub(/Controller$/,'').underscore
+    end
+  end
+end

data/lib/jets/build/lambda_deducer.rb

@@ -0,0 +1,23 @@
+# TODO: move the handler_generator.rb deducing methods into here
+class Jets::Build
+  class LambdaDeducer
+    attr_reader :handlers
+    def initialize(path)
+      @path = path
+    end
+
+    def class_name
+      @path.sub(%r{app/(\w+)/},'').sub('.rb','').classify
+    end
+
+    def functions
+      # Example: require "./app/controllers/posts_controller.rb"
+      require_path = @path.starts_with?('/') ? @path : "#{Jets.root}#{@path}"
+      require require_path
+
+      class_name
+      klass = class_name.constantize
+      klass.lambda_functions
+    end
+  end
+end

data/lib/jets/build/templates/handler.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const spawn = require('child_process').spawn;
+
+// Once hooked up to API Gateway can use the curl command to test:
+// curl -s -X POST -d @event.json https://endpoint | jq .
+
+// Filters out lines so only the error lines remain.
+// Uses the "RubyError: " marker to find the starting error lines.
+//
+// Input: String
+// random line
+// RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3
+//
+// Output: String
+// RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3
+function filterErrorLines(text) {
+  var lines = text.split("\n")
+  var markerIndex = lines.findIndex(line => line.startsWith("RubyError: ") )
+  lines = lines.filter((line, index) => index >= markerIndex )
+  return lines.join("\n")
+}
+
+// Produces an Error object that displays in the AWS Lambda test console nicely.
+// The backtrace are the ruby lines, not the nodejs shim error lines.
+// The json payload in the Lambda console looks something like this:
+//
+// {
+//   "errorMessage": "RubyError: RuntimeError: error in submethod",
+//   "errorType": "RubyError",
+//   "stackTrace": [
+//     [
+//       "line1",
+//       "line2",
+//       "line3"
+//     ]
+//   ]
+// }
+//
+// Input: String
+// RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3
+//
+// Output: Error object
+// { RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3 name: 'RubyError' }
+function customError(text) {
+  text = filterErrorLines(text) // filter for error lines only
+  var lines = text.split("\n")
+  var message = lines[0]
+  var error = new Error(message)
+  error.name = message.split(':')[0]
+  error.stack = lines.slice(0, lines.length-1) // drop final empty line
+                  .map(e => e.replace(/^\s+/g,'')) // trim leading whitespaces
+                  .join("\n")
+  return error
+}
+
+<% @functions.each do |function| %>
+module.exports.<%= function[:name] %> = (event, context, callback) => {
+  // Command: bin/jets process controller [event] [context] [handler]
+  var args = [
+    "process",
+    "<%= @process_type %>",     // controller (singular)
+    JSON.stringify(event),      // event
+    JSON.stringify(context),    // context
+    "<%= function[:handler] %>" // IE: handlers/controllers/posts.update
+  ]
+  var ruby = spawn("bin/jets", args);
+
+  // string concatation in javascript is faster than array concatation
+  // http://bit.ly/2gBMDs6
+  var stdout_buffer = ""; // stdout buffer
+  // In the processor_command we do NOT call puts directly and write to stdout
+  // because it will mess up the eventual response that we want API Gateway to
+  // process.
+  // The Lambda prints out function to whatever the return value the ruby method
+  ruby.stdout.on('data', function(data) {
+    // Not using console.log because it decorates output with a newline.
+    //
+    // Uncomment process.stdout.write to see stdout streamed for debugging.
+    // process.stdout.write(data)
+    stdout_buffer += data;
+  });
+
+  // react to potential errors
+  var stderr_buffer = "";
+  ruby.stderr.on('data', function(data) {
+    // not using console.error because it decorates output with a newline
+    stderr_buffer += data
+    process.stderr.write(data)
+  });
+
+  //finalize when ruby process is done.
+  ruby.on('close', function(exit_code) {
+    // http://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html#nodejs-prog-model-handler-callback
+
+    // succcess
+    if (exit_code == 0) {
+      var result
+      try {
+        result = JSON.parse(stdout_buffer)
+      } catch(e) {
+        // if json cannot be parse assume simple text output intended
+        process.stderr.write("WARN: error parsing json, assuming plain text is desired.")
+        result = stdout_buffer
+      }
+      callback(null, result);
+
+      // callback(null, stdout_buffer);
+    } else {
+
+      // TODO: if this works, allow a way to not decorate the error in case
+      // it actually errors in javascript land
+      // Customize error object with ruby error info
+      var error = customError(stderr_buffer)
+      callback(error);
+      // console.log("error!")
+    }
+  });
+}
+<% end %>
+
+// for local testing
+if (process.platform == "darwin") {
+  // fake event and context
+  var event = {"hello": "world"}
+  // var event = {"body": {"hello": "world"}} // API Gateway wrapper structure
+  var context = {"fake": "context"}
+  module.exports.<%= @functions.first[:name] %>(event, context, (error, message) => {
+    console.error("\nLOCAL TESTING OUTPUT")
+    if (error) {
+      console.error("error message: %o", error)
+    } else {
+      console.error("success message %o", message)
+      // console.log(JSON.stringify(message)) // stringify
+    }
+  })
+}