rapp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9ab80ffe08547a212b884149d0499ac841d9001e
+  data.tar.gz: c82ba799ec59598319f7e16c02f135174205e530
+SHA512:
+  metadata.gz: 9b2741fb99e4990e5aa894c9619a97df35e090a7802f463abca0fe87e9656bd4878a70294778237b0c0ef92fade3bdfc763cabeeba1d49d40de474cdc4d3280c
+  data.tar.gz: c7825966622ea7595df78a8f8893959b064e79127d1d24ab4b6c10521c922fac25144f52ff6da7367e8f832abc1697122644294168d916fd76a37151b4bc49bb

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rapp.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 StabbyCutyou
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# Rapp
+
+Rapp - The Ruby App Scaffolder
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rapp'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rapp
+
+## Usage
+
+Using Rapp is incredibly simple. It's designed to work like familiar scaffolders / builders in the ruby community (think `rails new`).
+
+Currently, Rapp is in early development, and additional features are forthcoming. There is a Roadmap at the bottom of the Readme to highlight some of the work I feel is important to prioritize before a full v1 release. In addition to features, this includes the internal organization of the code as well, as the current state is more prototypical than it is final release quality.
+
+### Ethos
+
+Rapp is not a framework for running an app or building an app from pieces-parts. In the future, there may be additional helpers to configure very common components in the ruby community, but the overall goal is to hand you a working application with a few common niceities, then get out of your way. Once you've generated the Rapp, the project is yours to do with as you see fit - the gem itself is not a dependencty of the app you create.
+
+Rapps are shells to house your app, in a familiar layout, to prevent you from having to write the same boring boilerplate time and time again.
+
+Rapp is in no way shape or form meant for building web applications. You are free to attempt this if you wish, but if thats your goal, you're much better off with Rails, Sinatra, pure Rack, or any number of alternatives.
+
+### Creating a new Rapp
+
+Creating a new Rapp is simple
+
+```shell
+rapp new my_new_rapp
+```
+
+The only requirement is that the directory must not exist / be empty, as a safegaurd against accidentally overwriting any existing projects or Rapps. Otherwise, thats it!
+
+If the command executed successuflly, you should see a report displaying the folders and files that Rapp created for you. After that, you're ready to start building your app!
+
+### Dependencies
+
+Rapp only installs 2 dependencies into your application - bundler and rake. Eventually, It will also include rspec, as well as a suite of specs for you to run to validate that the core underpinnings of Rapp are working as expected, in addition to your own custom specs.
+
+### Layout
+
+Rapp application structure looks like the following:
+
+* app/
+* app/models/
+* app/services/
+* app/jobs/
+* bin/
+* config/
+* config/environments/
+* config/initializers/
+* lib/
+* lib/tasks/
+* spec/
+* {app_name}.rb
+* Gemfile
+* Rakefile
+
+### {app_name}.rb
+
+Most of the generated code that Rapp creates lives here. This is the primary entry point for you application, and handles things such as:
+
+* Defining the environment
+* Providing an application level logger
+* Loading dependencies via Bundler
+* Adding core directories to the load path
+* Requiring configuration, initializers, and environment-specific settings
+* Requiring the contents of the app/ directory
+
+You're free to modify any of this code however you see fit - however, most of the code in your core app file is meant to be added to (and not removed) for the convenience of you, the developer. Be that as it may, you are still free to do whatever you want inside of this file.
+
+A future revision will be breaking this behavior out into an application base, so that everything isn't dumped into a single ruby class.
+
+### App directory
+
+This is likely a familiar concept to any Rails developer, with a few twists. Rails famously eschews the notion of keeping business logic in services - I do not eschew this practice, and believe it is the right way to keep a distinction between the logic of the application, and the data with which the application is modeled. You are free to use, ignore, remove, or otherwise throw out this directory as you see fit.
+
+Additionally, there is a directory for "jobs", a place for daemonized background or out of band work to go, to make working with things like Chore or Sidekiq easier out of the box.
+
+### Bin directory
+
+If your application were to require an executable binary, it would be placed here. Otherwise, you may feel free to remove this directory
+
+### Config directory
+
+Another familiar convention for Rails developers, this directory and it's structure is meant to work in the same fashion as Rails. Dependency specific configuration needs can be placed into config/, initializers for your apps boot-up can be placed into config/initializers/, and any code specific to an environment (production / development / test) can be placed into config/environments. The load order is as follows:
+
+1. The correct environment.rb (defaults to development)
+2. The contents of config/initializers/, in alphabetical order
+3. The contents of config/, in alphabetical order
+
+These are loaded after Bundler, but before anything in app/
+
+### Lib directory
+
+Used for the same purpose as a Rails app or Ruby gem. Any code that falls outside of the norms of app/ would be placed here. Additionally, you may place tasks in lib/tasks/, and they will be registered via the Rake integration
+
+### Spec directory
+
+Mostly reserved for future use, this is where both Rapp specific specs to ensure the well-being of your core application will reside, as well as application specific specs that you write to ensure your custom logic and behaviors are working correctly (You are writing tests... right?)
+
+### Rake
+
+Currently, Rapp comes with 1 predefined rake task, which is "console". This will boot up irb while loading your {app_name}.rb, which will load the rest of your app. This is aliased to "c" for convenience.
+
+## Roadmap
+
+At the moment, this gem serves to fit a need that I found myself having and figured others might be as well. To that end, my main goals are to provide a simple, stable core ruby app intended to be run as a simple cli program, daemonized process, or otherwise. Currently, my primary roadmap for development is:
+
+1. Generate specs for the users application
+2. Provide proper CLI for the binary, to make future command line functionality easier to implement
+3. Test ease of use integrating Chore / Sidekiq like job systems
+
+## Contributing
+
+1. Fork it ( https://github.com/StabbyCutyou/rapp/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/rapp

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rapp/builder'
+
+Rapp::Builder.new_app({"name"=>ARGV[0]})

data/lib/rapp/builder.rb

@@ -0,0 +1,61 @@
+require 'fileutils'
+require 'erb'
+require 'ostruct'
+
+module Rapp
+  DirectoryStructure = [
+    "app",
+    "app/models",
+    "app/services",
+    "app/jobs",
+    "bin",
+    "config",
+    "config/environments",
+    "config/initializers",
+    "lib",
+    "lib/tasks",
+    "spec"
+  ]
+  class Builder
+    class << self
+      def new_app(opts={})
+        # Get name
+        raise ArgumentError.new("You must provide a name") unless app_name = opts.delete("name")
+        # Check if folder exists
+        root_dir = "#{`pwd`.strip}/#{app_name}"
+        raise ArgumentError.new("Directory #{root_dir} already exists") if File.directory?(root_dir) 
+        # Check if it's empty
+        raise ArgumentError.new("Directory #{root_dir} not empty") unless Dir["#{root_dir}/*"].empty? 
+        
+        # Build the directory structure first
+        Dir.mkdir(root_dir)
+
+        DirectoryStructure.each do |dir|
+          dir_name = "#{root_dir}/#{dir}"
+          FileUtils.mkdir_p(dir_name) unless File.directory?(dir_name)
+        end
+        
+        # For each template, render it, place it in the folder structure it corresponds to
+        template_root = File.join(File.dirname(__FILE__), 'templates')
+        
+        # Construct the data object
+        template_binding = OpenStruct.new({:name=>app_name, :class_name=>classify(app_name)})
+        Dir["#{template_root}/**/*"].reject { |p| File.directory? p }.each do |template|
+          template_data = File.read(template)
+          relative_name = template.split("templates/")[1][0..-5]
+          # Hack to make the entry point ruby file share the same name as the app
+          relative_name = "#{app_name}.rb" if relative_name == "app.rb"
+          result = ERB.new(template_data).result(template_binding.instance_eval {binding})
+          File.write("#{root_dir}/#{relative_name}", result)
+        end
+
+        puts "Finished creating #{app_name}"
+        puts "#{`find ./#{app_name}`}"
+      end
+
+      def classify(string)
+        string.gsub(/(?<=_|^)(\w)/){$1.upcase}.gsub(/(?:_)(\w)/,'\1')
+      end
+    end
+  end
+end

data/lib/rapp/templates/Gemfile.erb

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem "bundler", "~> 1.7"
+gem "rake", "~> 10.0"

data/lib/rapp/templates/Rakefile.erb

@@ -0,0 +1,5 @@
+# Load project rake task files
+require 'bundler'
+Bundler.require(:default, ENV['APP_ENV'] || 'development')
+$: << File.expand_path("lib", File.dirname(__FILE__))
+Dir["lib/tasks/*.rake"].each { |f| import f }

data/lib/rapp/templates/app.rb.erb

@@ -0,0 +1,61 @@
+class <%= class_name %>
+  class Env
+    def initialize(env)
+      @env = env
+    end
+  
+    def to_s
+      @env.downcase
+    end
+  
+    def production?
+      @env == 'production'
+    end
+  
+    def development?
+      @env == 'development'
+    end
+  end
+
+  def self.env
+    @env ||= Env.new(ENV['APP_ENV'] ||= 'development')
+  end
+
+  def self.logger
+    @logger ||= Logger.new(ENV['APP_LOG_PATH'] || "./log/app.log").tap do |l|
+      l.level = Logger::DEBUG
+      l.formatter = lambda do |severity, datetime, progname, msg|
+         "[#{datetime} (#{Process.pid})] #{severity} : #{msg}\n"
+      end
+    end
+  end
+
+  # Load all dependent gems
+  require 'bundler'
+  Bundler.require(:default, self.env.to_s)
+
+  # Set up additional load paths
+
+  $:.unshift File.dirname("./")
+  $:.unshift File.dirname("./lib")
+  $:.unshift File.dirname("./config")
+  $:.unshift File.dirname("./app")
+
+  # Load the right environment initializer
+
+  require "config/environments/#{self.env.to_s}"
+  
+  # Load initializers
+  
+  Dir["./config/initializers/*"].reject { |p| File.directory? p }.each {|file| require file }
+
+  # Load config
+
+  Dir["./config/**/*"].reject { |p| File.directory? p }.each {|file| require file}
+  
+  # Load job files
+  
+  Dir["./app/models/**/*"].reject { |p| File.directory? p }.each {|file| require file }
+  Dir["./app/services/**/*"].reject { |p| File.directory? p }.each {|file| require file }
+  Dir["./app/jobs/**/*"].reject { |p| File.directory? p }.each {|file| require file }
+end

data/lib/rapp/templates/lib/tasks/console.rake.erb

@@ -0,0 +1,5 @@
+task :console do
+  exec 'irb -r ./<%=name%>.rb'
+end
+
+task :c => :console

data/lib/rapp/version.rb

@@ -0,0 +1,3 @@
+module Rapp
+  VERSION = "0.0.1"
+end

data/lib/rapp.rb

@@ -0,0 +1,5 @@
+require "rapp/version"
+
+module Rapp
+  
+end

data/rapp.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rapp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rapp"
+  spec.version       = Rapp::VERSION
+  spec.authors       = ["StabbyCutyou"]
+  spec.email         = ["sean.kelly@tapjoy.com"]
+  spec.summary       = %q{rapp - A gem for building Ruby Apps}
+  spec.description   = %q{tapp helps you build native ruby apps with a familiar structure and a handful of familiar conventions. Perfect for writing console apps or even daemons in Ruby!}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: rapp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- StabbyCutyou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: tapp helps you build native ruby apps with a familiar structure and a
+  handful of familiar conventions. Perfect for writing console apps or even daemons
+  in Ruby!
+email:
+- sean.kelly@tapjoy.com
+executables:
+- rapp
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/rapp
+- lib/rapp.rb
+- lib/rapp/builder.rb
+- lib/rapp/templates/Gemfile.erb
+- lib/rapp/templates/Rakefile.erb
+- lib/rapp/templates/app.rb.erb
+- lib/rapp/templates/config/environments/development.rb.erb
+- lib/rapp/templates/config/environments/production.rb.erb
+- lib/rapp/templates/config/environments/test.rb.erb
+- lib/rapp/templates/lib/tasks/console.rake.erb
+- lib/rapp/version.rb
+- rapp.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: rapp - A gem for building Ruby Apps
+test_files: []