staticmatic2 2.0.0

data/lib/staticmatic/compass.rb

@@ -0,0 +1,5 @@
+["installer", "configuration_defaults", "app_integration"].each do |file|
+ require File.join(File.dirname(__FILE__), "compass", file)
+end
+
+Compass.add_configuration(:staticmatic)

data/lib/staticmatic/compass/app_integration.rb

@@ -0,0 +1,18 @@
+
+module Compass
+  module AppIntegration
+    module Staticmatic
+
+      extend self
+      
+      def installer(*args)
+        Installer.new(*args)
+      end
+
+      def configuration
+        Compass::Configuration::Data.new('staticmatic').extend(ConfigurationDefaults)
+      end
+
+    end
+  end
+end

data/lib/staticmatic/compass/configuration_defaults.rb

@@ -0,0 +1,44 @@
+module Compass
+  module AppIntegration
+    module Staticmatic
+      module ConfigurationDefaults
+        def project_type_without_default
+          :staticmatic
+        end
+        
+        def http_path
+          "/"
+        end
+        
+        def sass_dir_without_default
+          "src/stylesheets"
+        end
+
+        def javascripts_dir_without_default
+          "site/javascripts"
+        end
+
+        def css_dir_without_default
+          "site/stylesheets"
+        end
+
+        def images_dir_without_default
+          "site/images"
+        end
+        
+        def default_http_images_path
+          "images"
+        end
+
+        def default_http_javascripts_path
+          "javascripts"
+        end
+        
+        def default_cache_dir
+          ".sass-cache"
+        end
+      end
+
+    end
+  end
+end

data/lib/staticmatic/compass/installer.rb

@@ -0,0 +1,15 @@
+module Compass
+  module AppIntegration
+    module Staticmatic
+      class Installer < Compass::Installers::ManifestInstaller 
+        def completed_configuration
+          nil
+        end
+        
+        def finalize(options = {})
+          puts manifest.welcome_message if manifest.welcome_message
+        end
+      end
+    end
+  end
+end

data/lib/staticmatic/configuration.rb

@@ -0,0 +1,20 @@
+module StaticMatic
+  class Configuration
+    attr_accessor :preview_server_port
+
+    attr_accessor :preview_server_host
+    
+    attr_accessor :use_extensions_for_page_links
+    attr_accessor :sass_options
+    attr_accessor :haml_options 
+    attr_accessor :coffee_options
+    
+    def initialize
+      self.preview_server_port = 3000
+      self.use_extensions_for_page_links = true
+      self.sass_options = {}
+      self.haml_options = {}
+      self.coffee_options = ''
+    end
+  end
+end

data/lib/staticmatic/deployers/aws-s3.rb

@@ -0,0 +1,71 @@
+require 'aws/s3'
+require 'yaml'
+
+class StaticExe < Thor
+
+  desc "s3_deploy DIRECTORY", "Deploys your static website an Amazon's S3 bucket"
+  method_option :env, :type => :string, :aliases => "-e"
+  method_option :skip_build, :type => :boolean, :aliases => "-k"
+  def s3_deploy(directory = '.')
+    return if needs_setup? directory
+    
+    invoke :build, directory unless options[:skip_build]
+    
+    if Dir[site_path(directory,'*')].empty?
+      say 'Your build/ folder is empty', :red
+      say 'Nothing to do.'
+      return
+    end
+    
+    say 'Uploading to Amazon S3...', :cyan
+    say 'Establishing connection to Amazon S3...'
+    amazon_config = YAML::load File.read(amazon_config_path directory)
+    AWS::S3::Base.establish_connection!(amazon_config['AccessKeys'])
+    
+    env = options[:env] || 'development'
+    bucket_name = amazon_config['Buckets'][env]
+    
+    say "Grabbing #{env} bucket '#{bucket_name}'"
+    buckets = AWS::S3::Service.buckets
+    unless buckets.map {|b| b.name}.include? bucket_name
+      say 'The bucket ', :red
+      say "'#{bucket_name}' "
+      say 'does not exist!', :red
+      say 'Nothing to do.'
+      return
+    end
+
+    Dir[site_path(directory,'*')].each do |file|
+      contents = File.read file
+      s3path = file.sub(%r{^\./build/},'')
+      
+      say "      upload ", :cyan; say s3path
+      AWS::S3::S3Object.store(s3path, contents, bucket_name, :access => :public_read)
+    end
+    say 'Done.'
+  end
+  
+  private
+  
+  def amazon_config_path(directory)
+    File.join(directory, 'config','amazon.yml')
+  end
+  
+  def needs_setup?(directory)
+    config_file = amazon_config_path(directory)
+    
+    unless File.exists? config_file
+      say 'You need an Amazon S3 config file.', :red
+      response = ask 'Would you like to generate one now? [Y/n]'
+
+      if response == '' || response.downcase == 'y'
+        copy_file lib_path('deployers/config/amazon.yml'), config_file
+        say 'Done.'
+        say 'Edit this config file to specify your Amazon S3 access keys, ' +
+            'and then try again.'
+        say 'For more information, visit http://aws.amazon.com/s3/'
+      end
+      return true
+    end
+  end
+end

data/lib/staticmatic/deployers/config/amazon.yml

@@ -0,0 +1,7 @@
+AccessKeys:
+  :access_key_id: Your-access-key-here
+  :secret_access_key: Your-secres-access-key-here
+
+Buckets:
+  development: Your-development-bucket
+  production: Your-production-bucket

data/lib/staticmatic/error.rb

@@ -0,0 +1,17 @@
+module StaticMatic
+  class Error < StandardError
+    attr_reader :line
+
+    attr_reader :filename
+    
+    def initialize(lineno, filename, message)
+      @line = lineno
+      @filename = filename
+      @message = message
+    end
+    
+    def message
+      "#{@filename}, line #{@line}: #{@message}"
+    end
+  end
+end

data/lib/staticmatic/helpers.rb

@@ -0,0 +1,12 @@
+["assets", "form", "current_path", "render", "tag", "url"].each do |helper|
+  require File.join(File.dirname(__FILE__), "helpers", "#{helper}_helper")
+end
+
+module StaticMatic::Helpers
+  include TagHelper
+  include UrlHelper  
+  include AssetsHelper
+  include FormHelper
+  include RenderHelper
+  include CurrentPathHelper  
+end

data/lib/staticmatic/helpers/assets_helper.rb

@@ -0,0 +1,116 @@
+module StaticMatic
+  module Helpers
+    module AssetsHelper
+      self.extend self
+      
+      # Generates links to all stylesheets in the source directory
+      # = stylesheets
+      # or specific stylesheets in a specific order
+      # = stylesheets :reset, :application
+      # Can also pass options hash in at the end so you can specify :media => :print
+      def stylesheets(*params)
+        options = if params.last.is_a? Hash; params.pop else {} end # clean up
+        
+        options[:media] = 'all' unless options.has_key?(:media)
+        options[:rel] = 'stylesheet'; options[:type] = 'text/css'
+
+        src_files = @staticmatic.src_file_paths('sass','scss','css')
+        output = ""
+
+        if params.length == 0
+          # no specified files; include them all!
+          src_files.each {|path| output << format_output(:link,path,options) }
+        else
+          # specific files requested and in a specific order
+          params.each do |file|
+
+            if file.to_s.match %r{^https?://}
+              output << format_output(:link,file,options)
+            else
+              idx = src_files.index do |src|
+                %w{sass scss css}.map {|t| src.match /#{file}\.#{t}$/ }.any?
+              end
+              output << format_output(:link,src_files[idx],options) unless idx.nil?
+            end
+          end
+        end
+        output
+      end
+      
+      # Generate javascript source tags for the specified files
+      #
+      # javascripts('test')   ->   <script language="javascript" src="javascripts/test.js"></script>
+      #    
+      def javascripts(*files)
+        options = if files.last.is_a? Hash; files.pop else {} end # clean up
+        
+        options[:language] = 'javascript'
+        options[:type] = 'text/javascript'
+        
+        src_files = @staticmatic.src_file_paths('js','coffee')
+        output = ""
+
+        files.each do |path|
+          puts "path: #{path}"
+          if path.to_s.match %r{^https?://}
+            output << format_output(:script,path,options)
+          else
+            idx = src_files.index do |src|
+              %w{coffee js}.map {|t| src.match /#{path.to_s}\.#{t}$/ }.any?
+            end
+            output << format_output(:script,src_files[idx],options) unless idx.nil?
+          end
+        end
+        output
+      end
+
+      # Generates an image tag always relative to the current page unless absolute path or http url specified.
+      # 
+      # img('test_image.gif')   ->   <img src="/images/test_image.gif" alt="Test image"/>
+      # img('contact/test_image.gif')   ->   <img src="/images/contact/test_image.gif" alt="Test image"/>
+      # img('http://localhost/test_image.gif')   ->   <img src="http://localhost/test_image.gif" alt="Test image"/>
+      def img(name, options = {})
+        options[:src] = name.match(%r{^((\.\.?)?/|https?://)}) ? name : "#{current_page_relative_path}images/#{name}"
+        options[:alt] ||= name.split('/').last.split('.').first.capitalize.gsub(/_|-/, ' ')
+        tag :img, options
+      end
+      
+      def format_output(tag_type,path,options)
+        external_url = !!path.match(%r{^https?://})
+
+        if external_url
+          src = path
+        else
+          filename_without_extension = File.basename(path).chomp(File.extname(path))
+      
+          path = path.gsub(/#{@staticmatic.src_dir}/, "").
+                      gsub(/#{@staticmatic.site_dir}/, "").
+                      gsub(/#{filename_without_extension}\.(sass|scss|css|js|coffee)/, "")
+
+          src = File.join(current_page_relative_path, path, "#{filename_without_extension}")
+        end
+        
+        if tag_type == :link
+          src += '.css' if !external_url
+          options[:href] = qstring(src, options[:qstring]); options.delete :qstring
+          tag(tag_type,options)
+        elsif tag_type == :script
+          src += '.js' if !external_url
+          options[:src] = qstring(src, options[:qstring]); options.delete :qstring
+          tag(tag_type,options) { '' }
+        end
+        
+      end
+      
+      # Prepares a query string based on the given qstr.
+      # If qstr is true, it generates a query string based on the current time.
+      # If qstr is a string, it uses it as the query string itself.
+      # 
+      def qstring(src,qstr)
+        src += '?_=' + Time.now.to_i.to_s if qstr == true
+        src += '?_=' + qstr if qstr.is_a? String
+        src
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/current_path_helper.rb

@@ -0,0 +1,22 @@
+module StaticMatic
+  module Helpers
+    module CurrentPathHelper
+      self.extend self
+      
+      def current_page
+        @staticmatic.current_page
+      end
+
+      private
+
+      def current_page_relative_path(current_path = nil)
+        if current_path.nil? || current_path.match(/^((\.\.?)?\/|\#|.+?\:)/) == nil
+          current_page_depth = current_page.split('/').length - 2;
+          (current_page_depth > 0) ? ([ '..' ] * current_page_depth).join('/') + '/' : ''
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/form_helper.rb

@@ -0,0 +1,23 @@
+
+module StaticMatic
+  module Helpers
+    module FormHelper
+      self.extend self
+
+      # Generates a form text field
+      #
+      def text_field(name, value, options = {})
+        options.merge!(:type => "text", :name => name, :value => value)
+        tag(:input, options)
+      end
+        
+        
+      # Generate a form textarea
+      #
+      def text_area(name, value, options = {})
+        options.merge!(:name => name)
+        tag(:textarea, options) { value }
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/render_helper.rb

@@ -0,0 +1,13 @@
+
+module StaticMatic
+  module Helpers
+    module RenderHelper
+      self.extend self
+      
+      # Include a partial template
+      def partial(name, options = {})
+        @staticmatic.generate_partial(name, options)
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/tag_helper.rb

@@ -0,0 +1,35 @@
+module StaticMatic
+  module Helpers
+    module TagHelper
+      self.extend self
+      
+      # Generates HTML tags:
+      #
+      # tag(:br)   ->   <br/>
+      # tag(:a, :href => 'test.html') { "Test" }    ->    <a href="test.html">Test</a>
+      #
+      def tag(name, options = {}, &block)
+        options[:id] ||= options[:name] if options[:name]
+        output = "<#{name}"
+        options.keys.sort { |a, b| a.to_s <=> b.to_s }.each do |key|
+          output << " #{key}=\"#{options[key]}\"" if options[key]
+        end
+        
+        if block_given?
+          output << ">"
+          output << yield
+          output << "</#{name}>"
+        else
+          format = @staticmatic.configuration.haml_options[:format]
+          
+          if format.nil? || format == :xhtml
+            output << "/>"
+          else
+            output << ">"
+          end
+        end
+        output
+      end
+    end
+  end
+end

data/lib/staticmatic/helpers/url_helper.rb

@@ -0,0 +1,59 @@
+module StaticMatic
+  module Helpers
+    module UrlHelper
+      self.extend self
+      
+      # Generate an HTML link
+      #
+      # If only the title is passed, it will automatically
+      # create a link from this value:
+      #
+      # link('Test')  ->  <a href="test.html">Test</a>
+      #
+      def link(title, href = "", options = {})
+        if href.is_a?(Hash)
+          options = href
+          href = ""
+        end
+
+        if href.nil? || href.strip.length < 1
+          path_prefix = ''
+          if title.match(/^(\.\.?)?\//)
+            # starts with relative path so strip it off and prepend it to the urlified title
+            path_prefix_match = title.match(/^[^\s]*\//)
+            path_prefix = path_prefix_match[0] if path_prefix_match
+            title = title[path_prefix.length, title.length]
+          end
+          href = path_prefix + urlify(title) + ".html"
+        end
+
+        options[:href] = "#{current_page_relative_path(href)}#{href}"
+        
+        local_page = (options[:href].match(/^(\#|.+?\:)/) == nil)
+        unless @staticmatic.configuration.use_extensions_for_page_links || !local_page
+          options[:href].chomp!(".html")
+          options[:href].chomp!("index") if options[:href][-5, 5] == 'index'
+        end
+
+        tag(:a, options) { title }
+      end
+      alias link_to link
+
+      # Generates a URL friendly string from the value passed:
+      #
+      # "We love Haml"  ->  "we_love_haml"
+      # "Elf & Ham"     ->  "elf_and_ham"
+      # "Stephen's gem" ->  "stephens_gem"
+      #
+      def urlify(string)
+        string.tr(" ", "_").
+               sub("&", "and").
+               sub("@", "at").
+               tr("^A-Za-z0-9_", "").
+               sub(/_{2,}/, "_").
+               downcase
+      end
+    end
+  end
+
+end