rugular 0.0.95

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5146630b5d70b0d26d71eb5bb4d4eff347405f98
+  data.tar.gz: 747b7d81fcdfaa2c70a9a64a32860b692eac5b40
+SHA512:
+  metadata.gz: 044165ce25868e12bc7457233718287d08722e5685a92c9eda1476dfff299738b064fb7fb65359da33caa0bba331ecbb80726eb468859e01bc4c8b73676040db
+  data.tar.gz: 090bf7d3aa4e36468082421d00846f4bdaff2f9cea94b6fdd6867299b4fa37b1e0d13cd62112514892fd3fe34b8553daa41aa42b76d8d45f59c0c87c7a4ae3cb

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - '2.1.5'
+

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rugular.gemspec
+gemspec
+gem 'guard-coffeescript', github: 'guard/guard-coffeescript', branch: 'master'

data/README.md

@@ -0,0 +1,149 @@
+[![Build Status](https://travis-ci.org/currica/rugular.svg)](https://travis-ci.org/currica/rugular)
+
+# Rugular
+
+Rugular is a ruby scaffolding framework to build AngularJS apps. It builds a
+minified and compressed version of a front-end into the ``./dist`` folder that
+can be served as a standalone AngularJS app. The goal of this framework is to
+create applications written with [best AngularJS
+practices](https://github.com/johnpapa/angularjs-styleguide); CoffeeScript
+optional.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rugular'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rugular
+
+## Start a new project
+
+```bash
+rugular new <project_name>
+```
+
+This will create the initial project template that follows [Google's Best
+Practices for an Angular App
+Structure](https://docs.google.com/document/d/1XXMvReO8-Awi1EZXAXS4PzDzdNvV6pGcuaF4Q9821Es/pub).
+<pre>
+├──  bower_components/
+├──  bower.json
+├──  Gemfile
+├──  package.json
+├──  src/
+│   ├──  app/
+│   │   ├──  app.module.coffee
+│   │   ├──  app.config.coffee
+│   │   ├──  app.controller.coffee
+│   │   ├──  app.controller.spec.coffee
+│   │   ├──  app.routes.coffee
+│   │   ├──  index.haml
+│   │   ├──  index.sass
+│   ├──  components/
+│   ├──  404.html
+│   ├──  500.html
+│   ├──  favico.ico
+</pre>
+
+## Development Server
+
+Rugular includes a built in server that will interpret Coffeescript/Haml/Sass
+and run a server on ``localhost:8080``. To run the server, type:
+
+```bash
+bundle exec rugular server
+```
+
+## Running the tests
+
+### Unit Tests
+
+Unit tests are included in the development server. To run these tests just once
+(perhaps for CI) run:
+
+```
+karma start karma.conf.js --single-run
+```
+
+### End to End tests
+
+End to end tests with protractor can be run with:
+
+```bash
+protractor
+```
+
+Please make sure you have mocha installed globally!
+
+### Rugular Generators
+
+#### Create a Route
+
+A route creates a angular route, controller, and view in the app folder.
+
+```bash
+rugular generate route <route_name>
+```
+
+This command will create a folder in the ``src/app`` directory that will
+contain a controller and service namespaced with a new module of the route
+name if one dos not already exist. It will also register the new module in the
+``app.module.js`` file.
+
+#### Create a Directive
+
+```bash
+rugular generate directive <directive_name>
+```
+
+This command will create a directive and controller namespaced with a new
+module of the feature name if one does not already exist. It will also register
+the new module in the ``app.module.js`` file.
+
+#### Create a Factory (TODO)
+
+```bash
+rugular generate factory <factory_name>
+```
+
+This command will create contain a factory namespaced with a new module of the
+feature name if one does not already exist. It will also register the new
+module in the ``app.module.js`` file.
+
+### Creating a component
+
+A component refers to shareable, abstracted angular modules. To create a
+component, simply run any generator command with the ``-c`` option and the
+service will be created in the ``src/components`` folder.
+
+
+## TODO (need to build)
+
+### Building the app
+
+Rugular builds a minified, compressed version of your app in the ``/dist``
+folder. To build the app run:
+
+```
+rugular build
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/currica/rugular/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
+
+## License
+Copyright 2014. Q-Centrix. MIT License.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'rubygems'
+
+require 'cucumber'
+require 'cucumber/rake/task'
+
+task default: %i(features)
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end

data/bin/rugular

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+
+require_relative '../lib/rugular'
+
+Rugular::Rugular.start
+

data/features/generator_for_directive.feature

@@ -0,0 +1,35 @@
+Feature: Rugular CLI
+  In order to generate an application route
+  As a user of the rugular framework
+  I want to bootstrap the templates necessary to carry this out
+
+  Scenario: Generating a route
+    When I set up Rugular and run "rugular generate directive test"
+    And the file "my-app/src/app/test/test.directive.coffee" should contain:
+      """
+      angular.module('test').controller('testController', testController)
+      """
+    And the file "my-app/src/app/test/test.directive.spec.coffee" should contain:
+      """
+      describe 'testController', ->
+      """
+    And the file "my-app/src/app/test/test.haml" should contain:
+      """
+      %h1 test
+      """
+    And the file "my-app/src/app/app.module.coffee" should contain:
+      """
+      'test'
+      """
+    And the file "my-app/src/app/test/test.module.coffee" should contain:
+      """
+      angular.module 'test', [
+      ]
+      """
+
+  Scenario: Generating a route in the components directory
+    When I set up Rugular and run "rugular generate directive -c test"
+    And the file "my-app/src/components/test/test.directive.coffee" should contain:
+      """
+      angular.module('test').controller('testController', testController)
+      """

data/features/generator_for_route.feature

@@ -0,0 +1,40 @@
+Feature: Rugular CLI
+  In order to generate an application route
+  As a user of the rugular framework
+  I want to bootstrap the templates necessary to carry this out
+
+  Scenario: Generating a route
+    When I set up Rugular and run "rugular generate route test"
+    And the file "my-app/src/app/test/test.controller.coffee" should contain:
+      """
+      angular.module('test').controller('testController', testController)
+      """
+    And the file "my-app/src/app/test/test.routes.coffee" should contain:
+      """
+      angular.module('test').config(testRouting)
+      """
+    And the file "my-app/src/app/test/test.controller.spec.coffee" should contain:
+      """
+      describe 'testController', ->
+      """
+    And the file "my-app/src/app/test/test.haml" should contain:
+      """
+      %h1 test
+      """
+    And the file "my-app/src/app/app.module.coffee" should contain:
+      """
+      'test'
+      """
+    And the file "my-app/src/app/test/test.module.coffee" should contain:
+      """
+      angular.module 'test', [
+        'ui.router'
+      ]
+      """
+
+  Scenario: Generating a route in the components directory
+    When I set up Rugular and run "rugular generate route -c test"
+    And the file "my-app/src/components/test/test.controller.coffee" should contain:
+      """
+      angular.module('test').controller('testController', testController)
+      """

data/features/new.feature

@@ -0,0 +1,29 @@
+Feature: Rugular CLI
+  In order to generate initial files
+  As a user of the rugular framework
+  I want bootstrap the files necessary to start hacking!
+
+  Scenario: New
+    When I run `rugular new my-app`
+    Then the exit status should be 0
+    Then the file "my-app/.gitignore" should contain:
+      """
+      bower_components
+      """
+    And the file "my-app/bower.json" should contain:
+      """
+      "name": "my-app",
+      """
+    And the file "my-app/package.json" should contain:
+      """
+      "name": "my-app",
+      """
+    And the file "my-app/karma.conf.js" should contain:
+      """
+      frameworks: ['mocha', 'chai', 'sinon', 'chai-sinon'],
+      """
+    And the file "my-app/src/index.haml" should contain:
+      """
+      = javascript_include_tag("./bower_components/angular-ui-router/release/angular-ui-router.js")
+      """
+

data/features/step_definitions/rugular_steps.rb

@@ -0,0 +1,3 @@
+When (/^I set up Rugular and run "(.*?)"$/) do |command|
+  system("cd tmp/aruba && rugular new my-app && cd my-app && #{command}")
+end

data/features/support/setup.rb

@@ -0,0 +1,2 @@
+Dir.glob("#{__dir__}/**/*.rb").each { |file| require file }
+require 'aruba/cucumber'

data/lib/rugular/tasks/build.rb

@@ -0,0 +1,27 @@
+Dir.glob("#{__dir__}/helpers/**/*.rb").each {|file| require file}
+
+module Rugular
+  class Build < Thor::Group
+    include Thor::Actions
+
+    desc('Creates a minified, compressed version in the dist folder')
+
+    Rugular::AppChecker.check_rugular!(self.name, new.destination_root)
+
+    # TODO: build from the ./.tmp folder
+    def compile_coffeescript
+      puts CoffeeScript.compile File.read("app.coffee")
+    end
+
+    def uglify_css
+      puts Uglifier.compile(CoffeeScript.compile File.read("app.coffee"))
+    end
+
+    def interpret_sass
+      template = File.load('stylesheets/sassy.sass')
+      sass_engine = Sass::Engine.new(template)
+      output = sass_engine.render
+      puts output
+    end
+  end
+end

data/lib/rugular/tasks/dependencies.rb

@@ -0,0 +1,28 @@
+Dir.glob("#{__dir__}/helpers/**/*.rb").each {|file| require file}
+
+module Rugular
+  class Dependencies < Thor::Group
+    include Thor::Actions
+
+    desc('Installs dependencies (bundle, bower and npm)')
+
+    Rugular::AppChecker.check_rugular!(self.name, new.destination_root)
+
+    def bundle
+      `bundle install`
+    end
+
+    def bower
+      `bower install`
+    end
+
+    def npm_install
+      `npm install`
+    end
+
+    # Protractor needs to be installed globally
+    def install_protractor
+      `npm install -g protractor coffee-script mocha`
+    end
+  end
+end

data/lib/rugular/tasks/generate/directive.rb

@@ -0,0 +1,11 @@
+require_relative 'generator_base'
+
+module Rugular
+  class Directive < GeneratorBase
+
+    def template_files
+      Dir.glob("#{lib_directory}/templates/directive/*.erb")
+    end
+
+  end
+end

data/lib/rugular/tasks/generate/generator_base.rb

@@ -0,0 +1,81 @@
+require 'ostruct'
+
+module Rugular
+  class GeneratorBase < Thor::Group
+    include Thor::Actions
+
+    argument :name, desc: 'Name for your route'
+
+    # specify a component
+    class_option(
+      :c,
+      type: :boolean,
+      desc: 'create the route in the component folder'
+    )
+
+    def self.source_root
+      __dir__.chomp('/tasks/generate')
+    end
+
+    def create_route_folders
+      route_pathnames.each do |pathname|
+        next(
+          "#{destination_file(pathname)} already exists"
+        ) if File.exists? destination_file(pathname)
+
+        create_file destination_file(pathname) do
+          ERB.new(pathname.read).result(
+            open_struct.instance_eval { binding }
+          )
+        end
+      end
+    end
+
+    def inject_module_into_app_module
+      insert_into_file(
+        app_module_file,
+        module_declaration,
+        after: "angular.module 'app', [\n"
+      ) unless module_declaration_present?
+    end
+
+    def template_files; []; end
+
+    protected
+
+    def folder
+      options[:c] ? "src/components/#{name}" : "src/app/#{name}"
+    end
+
+    def route_pathnames
+      Dir.glob(template_files).map do |file_name|
+        Pathname.new(file_name)
+      end
+    end
+
+    def destination_file(pathname)
+      "#{folder}/#{pathname.basename('.erb').to_s.gsub('app', name)}"
+    end
+
+    def open_struct
+      @_open_struct ||= OpenStruct.new(name: name)
+    end
+
+    def lib_directory
+      __dir__.chomp('/tasks/generate')
+    end
+
+    def app_module_file
+      'src/app/app.module.coffee'
+    end
+
+    def module_declaration
+      "  '#{name}'\n"
+    end
+
+    def module_declaration_present?
+      File.read(app_module_file).include? module_declaration
+    end
+
+  end
+end

data/lib/rugular/tasks/generate/route.rb

@@ -0,0 +1,11 @@
+require_relative 'generator_base'
+
+module Rugular
+  class Route < GeneratorBase
+
+    def template_files
+      Dir.glob("#{lib_directory}/templates/route/*.erb")
+    end
+
+  end
+end

data/lib/rugular/tasks/generate.rb

@@ -0,0 +1,44 @@
+Dir.glob("#{__dir__}/helpers/**/*.rb").each {|file| require file}
+Dir.glob("#{__dir__}/generate/**/*.rb").each {|file| require file}
+
+module Rugular
+  class Generate < Thor
+    include Thor::Actions
+
+    Rugular::AppChecker.check_rugular!(self.name, new.destination_root)
+
+    desc(
+      'generate <angular_service> <name>',
+      'generates an angular service'
+    )
+    long_desc <<-LONGDESC
+      The generate command creates a new angular service in either the app
+      folder (default) or the components folder with the `-c` option.
+
+      The angular services this command can create include:
+
+      * A route (includes a route, controller, controller_spec and view)
+      * A controller
+      * A factory
+      * A directive (includes a view)
+
+      The name that is passed in is the name of the angular service. The
+      command will also create an angular module if one does not already exist.
+    LONGDESC
+
+    register(
+      Rugular::Route,
+      'route',
+      'route',
+      'build an angular route'
+    )
+
+    register(
+      Rugular::Directive,
+      'directive',
+      'directive',
+      'build an angular directive'
+    )
+
+  end
+end

data/lib/rugular/tasks/helpers/app_checker.rb

@@ -0,0 +1,41 @@
+module Rugular
+  class AppChecker
+    include Thor::Shell
+
+    def self.check_rugular!(task_name, root_directory)
+      new(task_name: task_name, root_directory: root_directory).check_rugular!
+    end
+
+    def initialize(task_name:, root_directory:)
+      @task_name = task_name
+      @root_directory = root_directory
+    end
+
+    def check_rugular!
+      error(rugular_app_message) unless rugular_app?
+    end
+
+    private
+
+    attr_reader :task_name, :root_directory
+
+    def rugular_app_message
+      "#{task_name} requires a pre-existing Rugular application"
+    end
+
+    def rugular_app?
+      [
+        'bower.json',
+        'package.json',
+        'src/index.haml',
+        'Gemfile',
+        '.tmp'
+      ].each do |file_name|
+        destination_file_name = root_directory + '/' + file_name
+
+        return false unless File.exists?(destination_file_name)
+      end
+    end
+
+  end
+end

data/lib/rugular/tasks/new.rb

@@ -0,0 +1,52 @@
+require 'ostruct'
+require 'pathname'
+
+module Rugular
+  class New < Thor::Group
+    include Thor::Actions
+
+    argument :app_name, desc: 'Name for your application'
+    desc('Creates an initial folder structure for developing apps')
+
+    def self.source_root
+      __dir__.chomp('/tasks')
+    end
+
+    def create_application_directory
+      directory "#{lib_directory}/templates/new/", app_open_struct.name
+    end
+
+    def create_custom_files
+      Dir.glob("#{lib_directory}/templates/new_erb/*.erb").each do |file_name|
+        pathname = Pathname.new(file_name)
+
+        create_file "#{app_name}/#{pathname.basename('.erb').to_s}" do
+          ERB.new(pathname.read).result(
+            app_open_struct.instance_eval { binding }
+          )
+        end
+      end
+    end
+
+    def create_component_directory
+      empty_directory "#{app_name}/components"
+    end
+
+    def installation_complete
+      puts "Thank you for installing Rugular, please finish setting up your "\
+        "project with: `cd #{app_open_struct.name} && bundle install && "\
+        "rugular dependencies`"
+    end
+
+    private
+
+    def app_open_struct
+      @_app_open_struct ||= OpenStruct.new(name: app_name)
+    end
+
+    def lib_directory
+      __dir__.chomp('/tasks')
+    end
+
+  end
+end

data/lib/rugular/tasks/server/Guardfile

@@ -0,0 +1,22 @@
+# Only watch the src folder
+directories %w(src)
+
+# Create .tmp folder for localhost server and karma
+['haml', 'sass'].each do |language|
+  guard language, input: 'src', output: '.tmp', run_at_start: true do
+    watch %r{^src/.+\.#{language}}
+  end
+end
+
+
+input_dir = 'src'
+
+coffeescript_options = {
+  input: input_dir,
+  output: '.tmp',
+  patterns: [%r{^#{input_dir}/(.+\.(?:coffee|coffee\.md|litcoffee))$}]
+}
+
+guard 'coffeescript', coffeescript_options do
+  coffeescript_options[:patterns].each { |pattern| watch(pattern) }
+end

data/lib/rugular/tasks/server/Procfile

@@ -0,0 +1,5 @@
+web: ruby -run -e httpd .tmp --port 8080 &> /dev/null
+guard: bundle exec guard --guardfile=$(bundle show rugular)/lib/rugular/tasks/server/Guardfile
+karma: ./node_modules/karma/bin/karma start karma.conf
+selenium: webdriver-manager start &> /dev/null
+

data/lib/rugular/tasks/server.rb

@@ -0,0 +1,28 @@
+Dir.glob("#{__dir__}/helpers/**/*.rb").each {|file| require file}
+require 'open3'
+
+module Rugular
+  class Server < Thor::Group
+    include Thor::Actions
+
+    Rugular::AppChecker.check_rugular!(self.name, new.destination_root)
+
+    desc(
+      "runs the test suite and a dev server on localhost:8080 "\
+      "(set in lib/rugular/tasks/server/Procfile)"
+    )
+
+    def start_server
+      system(
+        "bundle exec foreman start --color --root=#{destination_root} " \
+        "--procfile=#{rugular_procfile}"
+      )
+    end
+
+    private
+
+    def rugular_procfile
+      "#{__dir__}/server/Procfile"
+    end
+  end
+end