fones 0.1.0

data/lib/forge/generator.rb

@@ -0,0 +1,144 @@
+
+module Fones
+  class Generator
+    class << self
+      def run(project, layout='default')
+        generator = self.new(project, layout)
+        generator.run
+      end
+    end
+
+    def initialize(project, layout='default')
+      @project = project
+      @task    = project.task
+      @layout  = layout
+    end
+
+    def create_structure
+      # Create the build directory for Fones output
+      @task.empty_directory @project.build_path
+
+      source_paths = [
+        ['assets', 'img'],
+        ['assets', 'js', 'libs'],
+        ['assets', 'css'],
+
+        ['functions', 'library', 'translation'],
+
+        ['includes'],
+
+        ['templates', 'pages'],
+        ['templates', 'partials'],
+      ]
+
+      # Build out Fones structure in the source directory
+      source_paths.each do |path|
+        @task.empty_directory File.join(@project.source_path, path)
+      end
+
+      self
+    end
+
+    def copy_images
+      source = File.expand_path(File.join(self.layout_path, 'img'))
+      target = File.expand_path(File.join(@project.assets_path, 'img'))
+
+      render_directory(source, target)
+    end
+
+    def copy_stylesheets
+      source = File.expand_path(File.join(self.layout_path, 'css'))
+      target = File.expand_path(File.join(@project.assets_path, 'css'))
+
+      render_directory(source, target)
+
+      self
+    end
+
+    def copy_javascript
+      source = File.expand_path(File.join(self.layout_path, 'js'))
+      target = File.expand_path(File.join(@project.assets_path, 'js'))
+
+      render_directory(source, target)
+
+      self
+    end
+
+    def copy_templates
+      source = File.expand_path(File.join(self.layout_path, 'templates'))
+      target = File.expand_path(File.join(@project.source_path, 'templates'))
+
+      render_directory(source, target)
+
+      self
+    end
+
+    def copy_functions
+      source = File.expand_path(File.join(self.layout_path, 'functions'))
+      target = File.expand_path(File.join(@project.source_path, 'functions'))
+
+      render_directory(source, target)
+    end
+
+    def layout_path
+      @layout_path ||= File.join(Fones::ROOT, 'layouts', @layout)
+    end
+
+    def run
+      write_config
+      create_structure
+      copy_images
+      copy_stylesheets
+      copy_javascript
+      copy_templates
+      copy_functions
+      return self
+    end
+
+    def write_config
+      unless File.exists?(@project.global_config_file)
+        @task.shell.mute do
+          @task.create_file(@project.global_config_file) do
+            "# Place your global configuration values here\n# config[:livereload] = true"
+          end
+        end
+      end
+
+      write_template(['config', 'config.tt'], @project.config_file)
+
+      self
+    end
+
+    def write_template(source, target)
+      source   = File.join(source)
+      template = File.expand_path(@task.find_in_source_paths((source)))
+      target   = File.expand_path(File.join(target))
+
+      @task.create_file target do
+        @project.parse_erb(template)
+      end
+    end
+
+    protected
+    def render_directory(source, target)
+      Dir.glob("#{source}/**/*") do |file|
+        unless File.directory?(file)
+          source_file = file.gsub(source, '')
+          target_file = File.join(target, source_file)
+
+          if source_file.end_with? ".erb"
+            target_file = target_file.slice(0..-5)
+
+            content = @project.parse_erb(file)
+          else
+            content = File.open(file).read
+          end
+
+          @task.create_file target_file do
+            content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forge/guard.rb

@@ -0,0 +1,65 @@
+require 'guard'
+require 'guard/guard'
+
+module Fones
+  module Guard
+
+    class << self
+      attr_accessor :project, :task, :builder
+    end
+
+    def self.add_guard(&block)
+      @additional_guards ||= []
+      @additional_guards << block
+    end
+
+    def self.start(project, task, options={}, livereload={})
+      @project = project
+      @task = task
+      @builder = Builder.new(project)
+
+      options_hash = ""
+      options.each do |k, v|
+        options_hash << ", :#{k} => '#{v}'"
+      end
+
+      assets_path = @project.assets_path.gsub(/#{@project.root}\//, '')
+      source_path = @project.source_path.gsub(/#{@project.root}\//, '')
+      config_file = @project.config_file.gsub(/#{@project.root}\//, '')
+
+      guardfile_contents = %Q{
+        guard 'forgeconfig'#{options_hash} do
+          watch("#{config_file}")
+        end
+        guard 'forgeassets' do
+          watch(%r{#{assets_path}/js/*})
+          watch(%r{#{assets_path}/css/*})
+          watch(%r{#{assets_path}/img/*})
+        end
+        guard 'forgetemplates' do
+          watch(%r{#{source_path}/templates/*})
+          watch(%r{#{source_path}/partials/*})
+        end
+        guard 'forgefunctions' do
+          watch(%r{#{source_path}/functions/*})
+          watch(%r{#{source_path}/includes/*})
+        end
+      }
+
+      if @project.config[:livereload]
+        guardfile_contents << %Q{
+          guard 'livereload' do
+            watch(%r{#{source_path}/*})
+          end
+        }
+      end
+
+      (@additional_guards || []).each do |block|
+        result = block.call(options, livereload)
+        guardfile_contents << result unless result.nil?
+      end
+
+      ::Guard.start({:guardfile_contents => guardfile_contents})
+    end
+  end
+end

data/lib/forge/project.rb

@@ -0,0 +1,162 @@
+require 'pathname'
+require 'compass'
+
+module Fones
+  class Project
+    class << self
+      def create(root, config, task)
+        root = File.expand_path(root)
+
+        project = self.new(root, task, config)
+        Generator.run(project)
+
+        project
+      end
+    end
+
+    attr_accessor :root, :config, :task
+
+    def initialize(root, task, config={}, config_file=nil)
+      @root        = File.expand_path(root)
+      @config      = config || {}
+      @task        = task
+      @config_file = config_file
+
+      self.load_config if @config.empty?
+    end
+
+    def assets_path
+      @assets_path ||= File.join(self.source_path, 'assets')
+    end
+
+    def build_path
+      File.join(self.root, '.forge', 'build')
+    end
+
+    def source_path
+      File.join(self.root, 'source')
+    end
+
+    def package_path
+      File.join(self.root, 'package')
+    end
+
+    def templates_path
+      File.join(self.source_path, 'templates')
+    end
+
+    def functions_path
+      File.join(self.source_path, 'functions')
+    end
+
+    def includes_path
+      File.join(self.source_path, 'includes')
+    end
+
+    def images_path
+      File.join(self.source_path, 'img')
+    end
+
+    def config_file
+      @config_file ||= File.join(self.root, 'config.rb')
+    end
+
+    def global_config_file
+      @global_config_file ||= File.join(ENV['HOME'], '.forge', 'config.rb')
+    end
+
+    # Create a symlink from source to the project build dir
+    def link(source)
+      source = File.expand_path(source)
+
+      unless File.directory?(File.dirname(source))
+        raise Fones::LinkSourceDirNotFound
+      end
+
+      @task.link_file build_path, source
+    end
+
+    def theme_id
+      File.basename(self.root).gsub(/\W/, '_')
+    end
+
+    def load_config
+      config = {}
+
+      # Check for global (user) config.rb
+      if File.exists?(self.global_config_file)
+        config.merge!(load_ruby_config(self.global_config_file))
+      end
+
+      # Check for config.rb
+      if File.exists?(self.config_file)
+        config.merge!(load_ruby_config(self.config_file))
+      else
+        # Old format of config file
+        if File.exists?(File.join(self.root, 'config.json'))
+          config.merge!(convert_old_config)
+        else
+          raise Error, "Could not find the config file, are you sure you're in a
+          forge project directory?"
+        end
+      end
+
+      @config = config
+    end
+
+    def get_binding
+      binding
+    end
+
+    def parse_erb(file)
+      ERB.new(::File.binread(file), nil, '-', '@output_buffer').result(binding)
+    end
+
+    private
+
+    def convert_old_config
+      require 'json'
+
+      # Let the user know what is going to happen
+      @task.say("It looks like you are using the old JSON-format config. Fones will now try converting your config to the new Ruby format.")
+      @task.ask(" Press any key to continue...")
+
+      begin
+        old_file_name = File.join(self.root, 'config.json')
+        # Parse the old config format, convert keys to symbols
+        @config = JSON.parse(File.open(old_file_name).read).inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+        @task.create_file(@config_file) do
+          # Find the config.tt template, and parse it using ERB
+          config_template_path = @task.find_in_source_paths(File.join(['config', 'config.tt']))
+          parse_erb(File.expand_path(config_template_path))
+        end
+      rescue Exception => e
+        @task.say "Error while building new config file:", Thor::Shell::Color::RED
+        @task.say e.message, Thor::Shell::Color::RED
+        @task.say "You'll need to either fix the error and try again, or manually convert your config.json file to Ruby format (config.rb)"
+        exit
+      end
+
+      @task.say "Success! Double-check that all your config values were moved over, and you can now delete config.json.", Thor::Shell::Color::GREEN
+
+      # We now have a Ruby config file, so we can continue loading as normal
+      return load_ruby_config(self.config_file)
+    end
+
+    def load_ruby_config(file)
+      config = {}
+
+      begin
+        # Config file is just executed as straight ruby
+        eval(File.read(file))
+      rescue Exception => e
+        @task.say "Error while evaluating config file:"
+        @task.say e.message, Thor::Shell::Color::RED
+      end
+
+      return config
+    end
+
+  end
+end

data/lib/forge/version.rb

@@ -0,0 +1,3 @@
+module Forge
+  VERSION = "0.0.2"
+end

data/lib/guard/forge/assets.rb

@@ -0,0 +1,31 @@
+require 'guard'
+require 'guard/guard'
+
+module Guard
+  class ForgeAssets < ::Guard::Guard
+
+    def initialize(watchers=[], options={})
+      super
+    end
+
+    def start
+      UI.info "Building all assets"
+      ::Fones::Guard.builder.build_assets
+    end
+
+    # Called on Ctrl-\ signal
+    # This method should be principally used for long action like running all specs/tests/...
+    def run_all
+      UI.info "Rebuilding all assets"
+      ::Fones::Guard.builder.clean_images
+      ::Fones::Guard.builder.build_assets
+    end
+
+    # Called on file(s) modifications
+    def run_on_change(paths)
+      UI.info "Assets have changed, rebuilding..."
+      ::Fones::Guard.builder.clean_images
+      ::Fones::Guard.builder.build_assets
+    end
+  end
+end

data/lib/guard/forge/config.rb

@@ -0,0 +1,34 @@
+require 'guard'
+require 'guard/guard'
+
+module Guard
+  class ForgeConfig < ::Guard::Guard
+    def initialize(watchers=[], options={})
+      super
+    end
+
+    # Called on Ctrl-Z signal
+    # This method should be mainly used for "reload" (really!) actions like reloading passenger/spork/bundler/...
+    def reload
+      UI.info "Reloading project config"
+      ::Fones::Guard.project.load_config
+    end
+
+    # Called on Ctrl-\ signal
+    # This method should be principally used for long action like running all specs/tests/...
+    def run_all
+      UI.info "Reloading project config"
+      ::Fones::Guard.project.load_config
+      true
+    end
+
+    # Called on file(s) modifications
+    def run_on_change(paths)
+      UI.info "Project config changed, reloading"
+      ::Fones::Guard.project.load_config
+      ::Fones::Guard.builder = ::Fones::Builder.new(::Fones::Guard.project)
+      # Rebuild everything if the config changes
+      ::Fones::Guard.builder.build
+    end
+  end
+end

data/lib/guard/forge/functions.rb

@@ -0,0 +1,33 @@
+require 'guard'
+require 'guard/guard'
+
+module Guard
+  class ForgeFunctions < ::Guard::Guard
+    def initialize(watchers=[], options={})
+      super
+    end
+
+    def start
+      UI.info "Copying functions over"
+      ::Fones::Guard.builder.copy_functions
+      ::Fones::Guard.builder.copy_includes
+    end
+
+    def run_all
+      UI.info "Rebuilding all functions"
+      ::Fones::Guard.builder.clean_functions
+      ::Fones::Guard.builder.copy_functions
+      ::Fones::Guard.builder.clean_includes
+      ::Fones::Guard.builder.copy_includes
+    end
+
+    # Called on file(s) modifications
+    def run_on_change(paths)
+      UI.info "Functions have changed, copying over"
+      ::Fones::Guard.builder.clean_functions
+      ::Fones::Guard.builder.copy_functions
+      ::Fones::Guard.builder.clean_includes
+      ::Fones::Guard.builder.copy_includes
+    end
+  end
+end