tay 0.0.2

data/lib/tay/cli/templates/gitignore

@@ -0,0 +1,5 @@
+*.DS_Store
+Gemfile.lock
+build/
+pkg/
+tmp/

data/lib/tay/cli/validate.rb

@@ -0,0 +1,21 @@
+module Tay
+  module CLI
+    class Root < ::Thor
+      desc 'validate', 'Validate 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 containing the built extension'
+      def validate
+        validator = SpecificationValidator.new(spec, build_dir)
+        validator.on_message = lambda do |type, message|
+          say(type.upcase + ": " + message, type == 'warn' ? :yellow : :red)
+        end
+
+        if validator.validate!
+          say("All OK!", :green)
+        end
+      end
+    end
+  end
+end

data/lib/tay/cli/watch.rb

@@ -0,0 +1,29 @@
+module Tay
+  module CLI
+    class Root < ::Thor
+      desc 'watch', 'Watch the current extension and recompile on file change'
+      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 watch
+        begin
+          require 'guard'
+          require 'guard/tay'
+        rescue LoadError
+          say('ERROR: please add the guard and guard-tay gems to your Gemfile to enable auto compilation', :red)
+          return
+        end
+
+        guardfile_path= "#{::Guard.locate_guard('tay')}/lib/guard/tay/templates/Guardfile"
+        guardfile = File.read(guardfile_path)
+
+        # Proxy in our command line options
+        guardfile.sub!(':tay do', ":tay, #{options.to_s} do")
+
+        Guard.setup
+        Guard.start(:guardfile_contents => guardfile)
+      end
+    end
+  end
+end

data/lib/tay/manifest_generator.rb

@@ -0,0 +1,160 @@
+module Tay
+  ##
+  # Takes a Tay::Specification and turns it in to a JSON representation
+  # that is eventually saved in to the manifest.json file.
+  #
+  # It also does basic sanity checks for missing required fields and common
+  # mistakes.
+  class ManifestGenerator
+    ##
+    # Pointer to the relevant Tay::Specification
+    attr_reader :spec
+
+    def initialize(specification)
+      @spec = specification
+    end
+
+    ##
+    # Return the JSON representation of the specification
+    def spec_as_json
+      json = {
+        :name => spec.name,
+        :version => spec.version,
+        :manifest_version => calculate_manifest_version
+      }
+
+      json[:description] = spec.description if spec.description
+      json[:icons] = spec.icons
+      json[:default_locale] = spec.default_locale if spec.default_locale
+      json[:browser_action] = action_as_json(spec.browser_action) if spec.browser_action
+      json[:page_action] = action_as_json(spec.page_action) if spec.page_action
+      json[:app] = packaged_app_as_json if spec.packaged_app
+      if spec.background_page
+        json[:background] = { :page => spec.background_page }
+      end
+      unless spec.background_scripts.empty?
+        json[:background] = { :scripts => spec.background_scripts }
+      end
+      json[:chrome_url_overrides] = spec.overriden_pages unless spec.overriden_pages.empty?
+      json[:content_scripts] = content_scripts_as_json unless spec.content_scripts.empty?
+      json[:content_security_policy] = spec.content_security_policy if spec.content_security_policy
+      json[:homepage_url] = spec.homepage if spec.homepage
+      json[:incognito] = spec.incognito_mode if spec.incognito_mode
+      json[:intents] = web_intents_as_json unless spec.web_intents.empty?
+      json[:minimum_chrome_version] = spec.minimum_chrome_version if spec.minimum_chrome_version
+      json[:nacl_modules] = nacl_modules_as_json unless spec.nacl_modules.empty?
+      json[:offline_enabled] = spec.offline_enabled unless spec.offline_enabled.nil?
+      json[:omnibox] = spec.omnibox_keyword if spec.omnibox_keyword
+      json[:options_page] = spec.options_page if spec.options_page
+      json[:permissions] = spec.permissions unless spec.permissions.empty?
+      json[:requirements] = requirements_as_json if has_requirements?
+      json[:update_url] = spec.update_url if spec.update_url
+      json[:web_accessible_resources] = spec.web_accessible_resources unless spec.web_accessible_resources.empty?
+
+      json
+    end
+
+    protected
+
+    ##
+    # Work out which manifest version needed based on the features that have
+    # been used
+    def calculate_manifest_version
+      return 2 unless spec.web_accessible_resources.empty?
+      1
+    end
+
+    ##
+    # Return the manifest representation of a page or browser action
+    def action_as_json(action)
+      json = {}
+      json[:default_title] = action.title if action.title
+      json[:default_icon] = action.icon if action.icon
+      json[:default_popup] = action.popup if action.popup
+      json
+    end
+
+    ##
+    # Return the manifest representation of a packaged app
+    def packaged_app_as_json
+      app = spec.packaged_app
+      json = {
+        :local_path => app.page
+      }
+
+      unless app.container.nil?
+        json[:container] = app.container
+        if app.container == 'panel'
+          json[:width] = app.width
+          json[:height] = app.height
+        end
+      end
+
+      json
+    end
+
+    ##
+    # Return the manifest representation of the content scripts, if any
+    def content_scripts_as_json
+      spec.content_scripts.map do |cs|
+        cs_json = {
+          :matches => cs.include_patterns
+        }
+
+        cs_json[:exclude_matches] = cs.exclude_patterns unless cs.exclude_patterns.empty?
+        cs_json[:run_at] = cs.run_at if cs.run_at
+        cs_json[:all_frames] = cs.all_frames unless cs.all_frames.nil?
+        cs_json[:css] = cs.stylesheets unless cs.stylesheets.empty?
+        cs_json[:js] = cs.javascripts unless cs.javascripts.empty?
+
+        cs_json
+      end
+    end
+
+    ##
+    # Return the manifest representation of handled web intents, if any
+    def web_intents_as_json
+      spec.web_intents.map do |wi|
+        {
+          :action => wi.action,
+          :title => wi.title,
+          :href => wi.href,
+          :types => wi.types,
+          :disposition => wi.disposition
+        }
+      end
+    end
+
+    ##
+    # Return the manifest representation of native client modules, if any
+    def nacl_modules_as_json
+      spec.nacl_modules.map do |nm|
+        {
+          :path => nm.path,
+          :mime_type => nm.mime_type
+        }
+      end
+    end
+
+    ##
+    # Return the manifest representation of any technology requirements
+    def requirements_as_json
+      features = []
+      features << 'webgl' if spec.requires_webgl
+      features << 'css3d' if spec.requires_3d_css_transitions
+
+      {
+        '3D' => {
+          :features => features
+        }
+      }
+    end
+
+    ##
+    # Calculates if the manifest should have a requirements field
+    def has_requirements?
+      spec.requires_webgl || spec.requires_3d_css_transitions
+    end
+
+  end
+end

data/lib/tay/packager.rb

@@ -0,0 +1,64 @@
+require 'crxmake'
+
+module Tay
+  ##
+  # Takes a Tay::Specification and builds it. It compiles the assets,
+  # writes the manifest, and copies everything to the output path.
+  class Packager
+    ##
+    # Pointer to the relevant Tay::Specification
+    attr_reader :spec
+
+    ##
+    # 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, build_dir)
+      @spec = specification
+      @base_dir = Pathname.new(base_dir)
+      @build_dir = Pathname.new(build_dir)
+    end
+
+    ##
+    # Write a signed zip file to out_path for upload to the Web Store
+    def write_zip(out_path)
+      CrxMake.zip(
+        :ex_dir => @build_dir,
+        :pkey   => full_key_path,
+        :zip_output => out_path,
+        :verbose => false
+      )
+    end
+
+    ##
+    # Write a signed crx file to out_path for self hosting
+    def write_crx(out_path)
+      CrxMake.make(
+        :ex_dir => @build_dir,
+        :pkey   => full_key_path,
+        :crx_output => out_path,
+        :verbose => false
+      )
+    end
+
+    ##
+    # Do we have an existing key file?
+    def private_key_exists?
+      full_key_path.exist?
+    end
+
+    ##
+    # Return the absolute path to the private key
+    def full_key_path
+      Pathname.new(spec.key_path).expand_path(@base_dir)
+    end
+
+    ##
+    # Generate a key with OpenSSL and write it to the key path
+    def write_new_key
+      File.open(full_key_path, 'w') do |f|
+        f.write OpenSSL::PKey::RSA.generate(1024).export()
+      end
+    end
+  end
+end

data/lib/tay/specification.rb

@@ -0,0 +1,261 @@
+require 'tay/specification/action'
+require 'tay/specification/page_action'
+require 'tay/specification/browser_action'
+require 'tay/specification/packaged_app'
+require 'tay/specification/content_script'
+require 'tay/specification/web_intent'
+require 'tay/specification/nacl_module'
+
+module Tay
+  ##
+  # A tay specification helps you define the functionality that the extension
+  # provides. It also serves as the data source that it used to generate the
+  # manifest.json file.
+  class Specification
+    ##
+    # http://code.google.com/chrome/extensions/manifest.html#name
+    attr_accessor :name
+
+    ##
+    # http://code.google.com/chrome/extensions/manifest.html#version
+    attr_accessor :version
+
+    ##
+    # http://code.google.com/chrome/extensions/manifest.html#description
+    attr_accessor :description
+
+    ##
+    # http://code.google.com/chrome/extensions/manifest.html#homepage_url
+    attr_accessor :homepage
+
+    ##
+    # http://code.google.com/chrome/extensions/manifest.html#default_locale
+    attr_accessor :default_locale
+
+    ##
+    # Path to an HTML file that will be used as the background page
+    attr_accessor :background_page
+
+    ##
+    # http://code.google.com/chrome/extensions/manifest.html#options_page
+    attr_accessor :options_page
+
+    ##
+    # http://code.google.com/chrome/extensions/omnibox.html
+    attr_accessor :omnibox_keyword
+
+    ##
+    # http://code.google.com/chrome/extensions/contentSecurityPolicy.html
+    attr_accessor :content_security_policy
+
+    ##
+    # http://code.google.com/chrome/extensions/manifest.html#minimum_chrome_version
+    attr_accessor :minimum_chrome_version
+
+    ##
+    # http://code.google.com/chrome/extensions/manifest.html#incognito
+    attr_accessor :incognito_mode
+
+    ##
+    # http://code.google.com/chrome/extensions/manifest.html#offline_enabled
+    attr_accessor :offline_enabled
+
+    ##
+    # Set this to true to mark the extension as requiring webgl support
+    attr_accessor :requires_webgl
+
+    ##
+    # Set this to true to mark the extension as requiring 3d css support
+    attr_accessor :requires_3d_css_transitions
+
+    ##
+    # http://code.google.com/chrome/extensions/autoupdate.html
+    attr_accessor :update_url
+
+    ##
+    # If you set this to a hash, it will be merged on top of the generated
+    # manifest. This is useful to force override of specific values
+    attr_accessor :manifest_data
+
+    ##
+    # An array of Tay::Specification::NaClModule
+    attr_accessor :nacl_modules
+
+    ##
+    # An array of Tay::Specification::ContentScript objects
+    attr_accessor :content_scripts
+
+    ##
+    # An array of Tay::Specification::WebIntent objects
+    attr_accessor :web_intents
+
+    ##
+    # An array javascript file paths that will run in the background
+    #
+    # http://code.google.com/chrome/extensions/background_pages.html
+    attr_accessor :background_scripts
+
+    ##
+    # An array of paths considered "web accessible"
+    #
+    # http://code.google.com/chrome/extensions/manifest.html#web_accessible_resources
+    attr_accessor :web_accessible_resources
+
+    ##
+    # An array of permissions the extension requires
+    #
+    # http://code.google.com/chrome/extensions/manifest.html#permissions
+    attr_accessor :permissions
+
+    ##
+    # An array of javascript paths that will be copied to the build
+    attr_accessor :javascripts
+
+    ##
+    # An array of stylesheet paths that will be copied to the build
+    attr_accessor :stylesheets
+
+    ##
+    # An map of icon sizes to paths
+    #
+    # http://code.google.com/chrome/extensions/manifest.html#icons
+    attr_accessor :icons
+
+    ##
+    # A map of Chrome page types to HTML files
+    attr_reader :overriden_pages
+
+    ##
+    # A Tay::Specification::BrowserAction or nil
+    attr_reader :browser_action
+
+    ##
+    # A Tay::Specification::PageAction or nil
+    attr_reader :page_action
+
+    ##
+    # A Tay::Specification::PackagedApp or nil
+    attr_reader :packaged_app
+
+    ##
+    # The path to the private key used to package this extension. Will default
+    # to ./EXTNAME.pem
+    attr_accessor :key_path
+
+    def initialize(&block)
+      @nacl_modules = []
+      @overriden_pages = {}
+      @web_accessible_resources = []
+      @permissions = []
+      @background_scripts = []
+      @content_scripts = []
+      @web_intents = []
+      @icons = {}
+      @stylesheets = []
+      @javascripts = []
+
+      yield self
+    end
+
+    ##
+    # Provide the path of the icon to be used at a certain size
+    def add_icon(size, path)
+      @icons[size.to_i] = path
+    end
+
+    ##
+    # Create a new Tay::Specification::BrowserAction and pass it to the block
+    # for set up.
+    def add_browser_action(&block)
+      raise Tay::InvalidSpecification.new('Browser action already set up') if @browser_action
+      @browser_action = BrowserAction.new
+      yield @browser_action
+    end
+
+    ##
+    # Create a new Tay::Specification::BrowserAction and pass it to the block
+    # for set up.
+    def add_page_action(&block)
+      raise Tay::InvalidSpecification.new('Page action already set up') if @page_action
+      @page_action = PageAction.new
+      yield @page_action
+    end
+
+    ##
+    # Create a new Tay::Specification::BrowserAction and pass it to the block
+    # for set up.
+    def add_packaged_app(&block)
+      raise Tay::InvalidSpecification.new('Packaged app already set up') if @packaged_app
+      @packaged_app = PackagedApp.new
+      yield @packaged_app
+    end
+
+    ##
+    # Add a content script to this extension. It will be passed to the block
+    # for set up. See Tay::Specification::ContentScript
+    def add_content_script(&block)
+      content_script = ContentScript.new
+      yield content_script
+      @content_scripts << content_script
+    end
+
+    ##
+    # Add a web intent to this extension. It will be passed to the block for
+    # set up. See Tay::Specification::WebIntent
+    def add_web_intent(&block)
+      web_intent = WebIntent.new
+      yield web_intent
+      @web_intents << web_intent
+    end
+
+    ##
+    # Add a native client module to this extension. It will be passed to the
+    # block for set up. See Tay::Specification::NaClModule
+    def add_nacl_module(&block)
+      nacl_module = NaClModule.new
+      yield nacl_module
+      @nacl_modules << nacl_module
+    end
+
+    ##
+    # Override a built in Chrome page with your own HTML file
+    #
+    # http://code.google.com/chrome/extensions/override.html
+    def override_page(page_type, path)
+      @overriden_pages[page_type] = path
+    end
+
+    ##
+    # Return all the javascript paths in the spec, included those nested
+    # inside other objects
+    def all_javascript_paths
+      all_paths = []
+      all_paths += @javascripts
+      all_paths += @background_scripts
+      all_paths += @content_scripts.map { |cs| cs.javascripts }.compact
+      all_paths.flatten.uniq
+    end
+
+    ##
+    # Return all the stylesheet paths in the spec, included those nested
+    # inside other objects
+    def all_stylesheet_paths
+      all_paths = []
+      all_paths += @stylesheets
+      all_paths += @content_scripts.map { |cs| cs.stylesheets }.compact
+      all_paths.flatten.uniq
+    end
+
+    ##
+    # Get the path to the private key for this extension
+    def key_path
+      @key_path || Utils.filesystem_name(name) + '.pem'
+    end
+
+    ##
+    # Does the specification have a certain permission?
+    def has_permission?(permission)
+      permissions.include?(permission)
+    end
+  end
+end