tay 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.DS_Store
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Thomas Rix
+
+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,135 @@
+# Tay
+
+Tay is designed to help you swiftly write Google Chrome extensions using your favourite languages and tools.
+
+## Installation
+
+    $ gem install tay
+
+## Usage
+
+Tay helps create, bootstrap, develop and publish Chrome extentions. It all works through the `tay` command. Running `tay` alone will show you a list of commands.
+
+### Creating
+
+To start work on a new extension, run `tay new [name]`. This will create a new directory, `[name]`, containing a predefined directory structure and files.
+
+Take particular note of the Gemfile, it contains several commented out gems which can unlock extra abilities for Tay. Just be sure to run `bundle install` after changes there.
+
+    Usage:
+      tay new NAME
+
+    Options:
+      [--no-gitignore=Don't create a .gitignore file]
+      [--no-gemfile=Don't create a Gemfile file]
+      [--use-coffeescript=Use CoffeeScript gem]
+      [--use-haml=Use haml gem]
+
+    Create a new extension
+
+### Developing
+
+Tay helps you use languages and techniques like CoffeeScript, CommonJS, SCSS and HAML. As mentioned above, tay generates a basic extension for you, from that point you can use generators to create various code skeletons.
+
+The heart any tay project is the `Tayfile`. It defines metadata  about your project and is also used to generate the `manifest.json` that Chrome requires. Some of the basic values will be pre-populated for you. For a full rundown of the Tayfile format, see the docs.
+
+If you install one of the JavaScript templating gems that Sprockets supports, you can require them like any other file and they'll be included in the `window.JST` object.
+
+#### Generators
+
+Tay ships with a handful of code skeleton generators, documented below. Running `tay generate` will show a list of generators; `tay generate help *generator_name*` will show information specific to that generator.
+
+Currently available generators: page_action, browser_action, content_script.
+
+#### Validating
+
+Tay can validate extensions. By running `tay validate` it will check for mutually-exclusive features and missing fields in specifications as well as ensure that referenced files actually exist.
+
+    Usage:
+      tay validate
+
+    Options:
+          [--tayfile=Use the specified tayfile instead of Tayfile]
+      -b, [--build-directory=The directory containing the built extension]
+          # Default: build
+
+    Validate the current extension
+
+#### Building
+
+To build the extension, run `tay build`. Source files will be compiled and written in to the build subdirectory by default. At this point, the unpacked extension can be loaded in to the browser by following the relevant section in Chrome's [getting started](http://code.google.com/chrome/extensions/getstarted.html) tutorial.
+
+    Usage:
+      tay build
+
+    Options:
+          [--tayfile=Use the specified tayfile instead of Tayfile]
+      -b, [--build-directory=The directory to build in]
+          # Default: build
+
+    Build the current extension
+
+If you run `tay watch` in the top level directory, tay will automatically build whenever a change is detected in the `src` directory *(you still need to go and reload the unpacked extension in Chrome)*.
+
+To use `tay watch` you'll need to add the `[guard-tay](http://github.com/rixth/guard-tay` gem to your Gemfile and run `bundle install`. If you want to customize the directories that are watched for changes, you can generate a [Guardfile](http://github.com/guard/guard) by running `guard init tay`.
+
+    Usage:
+      tay watch
+
+    Options:
+          [--tayfile=Use the specified tayfile instead of Tayfile]
+      -b, [--build-directory=The directory to build in]
+          # Default: build
+
+    Watch the current extension and recompile on file change
+
+### Minifying
+
+If you have the `[uglifier](https://github.com/lautis/uglifier)` and/or `[yui-compressor](https://github.com/sstephenson/ruby-yui-compressor)` gems in your Gemfile, you will be able to minify the JS and CSS in a built extension.
+
+    Usage:
+      tay minify
+
+    Options:
+          [--tayfile=Use the specified tayfile instead of Tayfile]
+      -b, [--build-directory=The directory containing the built extension]
+          # Default: build
+          [--skip-js=Don't minify *.js files]
+          [--skip-css=Don't minify *.css files]
+
+    Minify the CSS and JS of the currently built extension
+
+### Packaging
+
+When it comes time to publish your extension, Tay can create both .zip files (default, for submission to the Chrome Web Store) and .crx files (for self-hosting) via the `tay package` command.
+
+There are [certain requirements](http://code.google.com/chrome/extensions/packaging.html) with regards to private keys to allow updates to your extension without changing its ID. Tay will generate a key and place it in the project root. It's up to you whether this gets checked in to version control (not recommended for public GitHub projects). If a key is already present when the packager is run, it will be used.
+
+The filename of the key can be specified using by setting `key_path` in the Tayfile.
+
+    Usage:
+      tay package
+
+    Options:
+          [--tayfile=Use the specified tayfile instead of Tayfile]
+      -b, [--build-directory=The directory containing the built extension]
+          # Default: build
+      -t, [--type=The file type to build, zip or crx]
+          # Default: zip
+
+    Package the current extension
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## TODO
+
+* Generators that can also make haml/coffeescript
+* Localization of extensions
+* Generator for extension option pages

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+task :doc do
+  `sdoc`
+end

data/bin/tay

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'bundler/setup'
+require 'tay'
+Bundler.require if File.exists?('Gemfile')
+
+begin
+  require 'tay/cli'
+  Tay::CLI::Root.start
+rescue Interrupt => e
+  puts "\nQuitting..."
+  exit 1
+rescue SystemExit => e
+  exit e.status
+end

data/lib/tay.rb

@@ -0,0 +1,19 @@
+require 'bundler/setup'
+
+require 'fileutils'
+require 'pathname'
+require 'json'
+
+require 'tay/version'
+require 'tay/utils'
+require 'tay/specification'
+require 'tay/specification_validator'
+require 'tay/manifest_generator'
+require 'tay/builder'
+require 'tay/packager'
+
+module Tay
+  class InvalidSpecification < Exception; end
+  class SpecificationNotFound < Exception; end
+  class InvalidPackageType < Exception; end
+end

data/lib/tay/builder.rb

@@ -0,0 +1,173 @@
+require 'tilt'
+require 'sprockets'
+
+module Tay
+  ##
+  # Takes a Tay::Specification and builds it. It compiles the assets,
+  # writes the manifest, and copies everything to the output path.
+  class Builder
+    ##
+    # Pointer to the relevant Tay::Specification
+    attr_reader :spec
+
+    ##
+    # Set to true for debug output
+    attr_accessor :debug
+
+    ##
+    # Create a new builder. You must pass the specification, full path to the
+    # source directory and an optional output directory which defaults to
+    # base_dir + '/build'
+    def initialize(specification, base_dir, output_dir = nil)
+      @spec = specification
+      @base_dir = Pathname.new(base_dir)
+      @output_dir = output_dir ? Pathname.new(output_dir) : @base_dir.join('build')
+      create_sprockets_environment
+    end
+
+    ##
+    # Do the building. This simply delegates to the private methods
+    # in this class.
+    def build!
+      create_output_directory
+      simple_compile_directory('html')
+      simple_compile_directory('assets')
+      compile_files(spec.all_javascript_paths)
+      compile_files(spec.all_stylesheet_paths)
+      write_manifest
+    end
+
+    ##
+    # This is sub-optimal but the mustache/js gem does not require its tilt
+    # template automatically.
+    def self.try_to_load_mustache_trimmer
+      begin
+        require 'tilt/mustache_js_template'
+        Sprockets.register_engine '.mustache', Tilt::MustacheJsTemplate
+      rescue LoadError
+      end
+    end
+
+    protected
+
+    ##
+    # Given a path, run it through tilt and return the compiled version.
+    # If there's no known engine for it, just return the content verbatim.
+    # If we know the type buy are missing the gem, raise an exception.
+    def get_compiled_file_content(path)
+      begin
+        Tilt.new(path.to_s).render
+      rescue RuntimeError
+        File.read(path)
+      end
+    end
+
+    ##
+    # Create the output directory if it does not exist
+    def create_output_directory
+      FileUtils.mkdir_p @output_dir
+    end
+
+    ##
+    # Copy all the files from a directory to the output, compiling
+    # them if they are familiar to us. Does not do any sprocketing.
+    def simple_compile_directory(directory)
+      Dir[@base_dir.join('src', directory, '**/*')].each do |path|
+        file_in_path = Pathname.new(path)
+        file_out_path = asset_output_filename(src_path_to_out_path(path), Tilt.mappings.keys)
+
+        content = get_compiled_file_content(file_in_path)
+
+        FileUtils.mkdir_p(file_out_path.dirname)
+        File.open(file_out_path, 'w') do |f|
+          f.write content
+        end
+      end
+    end
+
+    ##
+    # Process all the files in the directory through sprockets before writing
+    # them to the output directory
+    def compile_files(files)
+      files.each do |base_path|
+        # We do this second glob in case the path provided in the tayfile
+        # references a compiled version
+        Dir[@base_dir.join('src', base_path + '*')].each do |path|
+          path = Pathname.new(path).relative_path_from(@base_dir.join('src'))
+          file_in_path = @base_dir.join('src', path)
+          file_out_path = asset_output_filename(@output_dir.join(path), @sprockets.engines.keys)
+
+          if @sprockets.extensions.include?(path.extname)
+            content = @sprockets[file_in_path].to_s
+          else
+            content = File.read(file_in_path)
+          end
+
+          FileUtils.mkdir_p(file_out_path.dirname)
+          File.open(file_out_path, 'w') do |f|
+            f.write content
+          end
+        end
+      end
+    end
+
+    ##
+    # Generate the manifest from the spec and write it to disk
+    def write_manifest
+      generator = ManifestGenerator.new(spec)
+
+      File.open(@output_dir.join('manifest.json'), 'w') do |f|
+        f.write JSON.pretty_generate(generator.spec_as_json)
+      end
+    end
+
+    ##
+    # Set up the sprockets environment for munging all the things
+    def create_sprockets_environment
+      @sprockets = Sprockets::Environment.new
+      @sprockets.append_path(@base_dir.join('src/javascripts').to_s)
+      @sprockets.append_path(@base_dir.join('src/templates').to_s)
+      @sprockets.append_path(@base_dir.join('src/stylesheets').to_s)
+      @sprockets.append_path(@base_dir.join('src').to_s)
+      @sprockets.append_path(@base_dir.to_s)
+    end
+
+    ##
+    # Debug message helper
+    def dbg(msg)
+      puts dbg if debug
+    end
+
+    ##
+    # Helper function that converts a base_dir/src/XYZ path to the equivalent
+    # path in the output directory
+    def src_path_to_out_path(path)
+      @output_dir.join(path.to_s.sub(/\A#{@base_dir.to_s}\/src\//, ''))
+    end
+
+    ##
+    # Helper function to convert the filenames of assets requiring pre-
+    # processing to their compiled extension. However, if the file only
+    # has one extension, it will be left alone regardless. Examples:
+    #
+    # * "foobar.module.js.coffee" => "foobar.module.js"
+    # * "index.html.haml" => "index.html"
+    # * "style.scss" => "style.scss"
+    def asset_output_filename(path, processed_extensions)
+      path = Pathname.new(path) if path.is_a?(String)
+
+      return path if path.basename.to_s.split('.').length == 2
+
+      extension = path.extname
+      processed_extensions.map! { |ext| (ext[0] != '.' ? '.' : '') + ext }
+
+      if processed_extensions.include?(extension)
+        asset_output_filename(path.to_s.sub(/#{extension}\Z/, ''), processed_extensions)
+      else
+        path
+      end
+    end
+  end
+
+  Builder.try_to_load_mustache_trimmer
+end

data/lib/tay/cli.rb

@@ -0,0 +1,29 @@
+require 'thor'
+require 'thor/group'
+require 'tay/cli/helpers'
+
+module Tay
+  ##
+  # Runs tay's command line interface
+  module CLI
+    class Root < ::Thor
+      include ::Thor::Actions
+      include ::Tay::CLI::Helpers
+
+      require 'tay/cli/generate'
+      register(Tay::CLI::Generate, 'generate', 'generate', 'Generate a feature')
+
+      require 'tay/cli/new'
+      require 'tay/cli/build'
+      require 'tay/cli/watch'
+      require 'tay/cli/generate'
+      require 'tay/cli/validate'
+      require 'tay/cli/minify'
+      require 'tay/cli/package'
+
+      def self.source_root
+        File.expand_path('cli/templates', File.dirname(__FILE__))
+      end
+    end
+  end
+end

data/lib/tay/cli/build.rb

@@ -0,0 +1,15 @@
+module Tay
+  module CLI
+    class Root < ::Thor
+      desc 'build', 'Build the current extension'
+      method_option 'tayfile', :type => :string,
+        :banner => 'Use the specified tayfile instead of Tayfile'
+      method_option 'build-directory', :type => :string, :default => 'build',
+        :aliases => '-b', :banner => 'The directory to build in'
+      def build
+        builder = Builder.new(spec, base_dir, build_dir)
+        builder.build!
+      end
+    end
+  end
+end