awestruct 0.2.18 → 0.4.2.x1

data/bin/awestruct

@@ -3,278 +3,6 @@
 $: << File.dirname(__FILE__) + '/../lib'
 
 require 'rubygems'
-require 'optparse'
-require 'awestruct/version'
-require 'awestruct/commands/init'
-require 'awestruct/commands/generate'
-require 'awestruct/commands/server'
-require 'awestruct/commands/deploy'
-require 'awestruct/commands/git_hub_pages'
-require 'yaml'
-require 'fssm'
-require 'fileutils'
+require 'awestruct/cli/invoker'
 
-def parse(args)
-  options = OpenStruct.new( {
-              :generate=>true,
-              :server=>false,
-              :port=>4242,
-              :bind_addr=>'0.0.0.0',
-              :auto=>false,
-              :force=>false,
-              :init=>false,
-              :framework=>'compass',
-              :scaffold=>true,
-              :base_url=>nil,
-              :profile=>nil,
-              :deploy=>false,
-              :script=>nil,
-            } )
-
-  opts = OptionParser.new do |opts|
-    opts.on( '-i', '--init', 'Initialize a new project in the current directory' ) do |init|
-      options.init     = init
-      options.generate = false
-    end
-    opts.on( '-f', '--framework FRAMEWORK', 'Specify a compass framework during initialization (bootstrap, blueprint, 960)' ) do |framework|
-      options.framework = framework
-    end
-    opts.on( '--[no-]scaffold', 'Create scaffolding during initialization (default: true)' ) do |s|
-      options.scaffold = s
-    end
-    opts.on( '--force', 'Force a regeneration' ) do |force|
-      options.force = force
-    end
-    opts.on( '-s', '--server', 'Serve generated site' ) do |s|
-      options.server = s
-    end
-    opts.on( '-u', '--url URL', 'Set site.base_url' ) do |url|
-      options.base_url = url
-    end
-    opts.on( '-d', '--dev',     'Run in development mode (--auto, --server and -profile development)' ) do |url|
-      options.server   = true
-      options.auto     = true
-      options.port     = 4242
-      options.profile  = 'development'
-    end
-
-    opts.on( '-P', '--profile PROFILE', 'Specify a profile' ) do |profile|
-      options.profile = profile
-    end
-
-    opts.on( '--deploy', 'Deploy site' ) do |deploy|
-      options.deploy = deploy
-    end
-
-    opts.on( '-a', '--auto', 'Auto-generate when changes are noticed' ) do |a|
-      options.auto = a
-    end
-    opts.on( '-p', '--port PORT', Integer, 'Server port (default: 4242)' ) do |port|
-      options.port = port
-    end
-    opts.on( '-b', '--bind ADDR', 'Server address (default: 0.0.0.0)' ) do |bind_addr|
-      options.bind_addr = bind_addr
-    end
-    opts.on( '-g', '--[no-]generate', 'Generated site' ) do |g|
-      options.generate = g
-    end
-    opts.on( '--run SCRIPT', 'Force a regeneration' ) do |script|
-      options.script = script
-    end
-
-    opts.separator ''
-    opts.separator "Common options:"
-
-    opts.on_tail("-h", "--help", "Show this message") do
-      puts opts
-      exit
-    end
-
-    opts.on_tail("-v", "--version", "Display the version") do
-      puts "Awestruct: #{Awestruct::VERSION}"
-      puts "http://awestruct.org/"
-      exit
-    end
-
-  end
-
-  opts.parse!(args)
-  options
-end
-
-def site_path
-  dir = (@profiles_data.nil? || @profile_data.nil? || @profile_data['output_dir'].nil?) ? '_site' : @profile_data['output_dir']
-  path = File.join( Dir.pwd, dir )
-end
-
-options = parse(ARGV)
-
-unless options.init
-  site_yaml_file = File.join( Dir.pwd, '_config', 'site.yml' )
-  site_yaml      = YAML.load( File.read( site_yaml_file ) )
-  if site_yaml
-    @profiles_data  = site_yaml['profiles'] || {}
-    @profile_data = if @profiles_data.nil?
-      nil
-    else
-      if options.profile
-        @profiles_data[options.profile]
-      else
-        # if no profile given, pick the first with deploy config
-        options.profile, profile_data = @profiles_data.select { |k,v| v && v['deploy'] }.first
-        profile_data
-      end
-    end
-  end
-end
-
-config = Awestruct::Config.new(Dir.pwd)
-
-if ( options.init )
-  if ( options.generate || options.auto || options.server )
-    $stderr.puts "--init may not be used with --generate, --auto or --server"
-    exit
-  end
-  cmd = Awestruct::Commands::Init.new( Dir.pwd, options.framework, options.scaffold )
-  cmd.run
-  exit
-end
-
-default_base_url = 'http://localhost:4242'
-
-def camelize(str)
-  str.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-end
-
-if ( options.script )
-  puts "Running #{options.script} and exiting"
-  require "awestruct/scripts/#{options.script}"
-  script_class = eval "Awestruct::Scripts::#{camelize(options.script)}"
-  script = script_class.new(*ARGV)
-  script.run
-  exit
-end
-
-if ( options.server )
-  hostname = ( options.bind_addr == '0.0.0.0' ? 'localhost' : options.bind_addr )
-  default_base_url = "http://#{hostname}:#{options.port}"
-end
-
-if ( options.force )
-  if File.exist?( site_path )
-    FileUtils.rmdir( site_path )
-  end
-end
-
-if ( options.generate )
-  cmd = Awestruct::Commands::Generate.new( config, options.profile, options.base_url, default_base_url, options.force )
-  cmd.run
-end
-
-if ( options.deploy )
-  if ( options.auto || options.server )
-    $stderr.puts "--deploy may not be used with --auto or --server"
-    exit
-  end
-
-  if ( ! options.profile )
-    $stderr.puts "You must specify a --profile when using --deploy"
-    exit
-  end
-
-  if ( @profiles_data.nil? )
-    $stderr.puts "_config/site.yml must define a 'profiles' section"
-    exit
-  end
-
-  if ( @profile_data.nil? )
-    $stderr.puts "Unknown profile '#{options.profile}'"
-    exit
-  end
-
-  if ( ! File.exist?( site_path ) )
-    $stderr.puts "No #{site_path}/ generated yet."
-    exit
-  end
-
-  deploy_data = @profile_data['deploy']
-  if ( deploy_data.nil? )
-    $stderr.puts "No configuration for 'deploy'"
-    exit
-  end
-
-  puts "deploying to '#{options.profile}'"
-  if (deploy_data['host'] == 'github_pages')
-    puts "publishing to github pages"
-    cmd = Awestruct::Commands::GitHubPages.new( site_path )
-  else
-    cmd = Awestruct::Commands::Deploy.new( site_path, deploy_data )
-  end
-  cmd.run
-  puts "deploy finished"
-  exit
-end
-
-threads = []
-
-if ( options.auto )
-  threads << Thread.new {
-    generate_cmd = Awestruct::Commands::Generate.new( config, options.profile, options.base_url, default_base_url )
-
-    monitor = FSSM::Monitor.new
-
-    call_generate = lambda do |base, relative|
-      # Convert to absolute path and append file separator if necessary.
-      base = File::expand_path(base)
-      if base[base.length - 1] != File::SEPARATOR
-        base += File::SEPARATOR
-      end
-
-      # Filter out bad input just in case.
-      if base.length < config.input_dir.length or config.input_dir != base[0..config.input_dir.length]
-        return
-      end
-
-      path = base + relative
-      path = path[config.input_dir.length..path.length]
-
-      if path =~ /^(_site|_tmp|\.git|\.gitignore|\.sass-cache|\.|\.\.).*/
-        return
-      end
-      if path =~ /.*(~|\.(swp|bak|tmp))$/
-        return
-      end
-
-      puts "Triggered regeneration: #{path}"
-      generate_cmd.run
-      puts "Done"
-      if relative == '.'
-        # It's necessary to restart the monitor on individual files
-        # after a change is handled
-        monitor.file(base) do
-          update &call_generate
-          create &call_generate
-        end
-      end
-    end
-
-    monitor.path(config.input_dir) do
-      update &call_generate
-      create &call_generate
-    end
-
-    monitor.run
-  }
-end
-
-if ( options.server )
-  threads << Thread.new {
-    puts "Serving site at #{site_path}"
-    server_cmd = Awestruct::Commands::Server.new( site_path, options.bind_addr, options.port )
-    server_cmd.run
-  }
-end
-
-threads.each do |thr|
-  thr.join
-end
+Awestruct::CLI::Invoker.new( ARGV ).invoke!

data/lib/awestruct/astruct.rb

@@ -0,0 +1,22 @@
+require 'awestruct/astruct_mixin'
+
+module Awestruct
+
+  class AStruct < Hash
+
+    include AStructMixin
+
+    def initialize(hash=nil)
+      hash.each{|k,v| self[k]=v } if hash
+    end
+
+    alias_method :original_entries, :entries
+    undef entries
+
+    def inspect
+      "AStruct{...}"
+    end
+  
+  end
+
+end

data/lib/awestruct/astruct_mixin.rb

@@ -0,0 +1,81 @@
+
+require 'awestruct/dependencies'
+
+module Awestruct
+
+  module AStructMixin
+
+    def self.extended(o)
+      class << o
+        alias_method :original_entries, :entries
+        undef entries
+      end
+    end
+
+    def cascade_for_nils!
+      @cascade_for_nils = true 
+      self
+    end
+
+    def key?(key)
+      super( key ) || super( key.to_sym ) || super( key.to_s )
+    end
+
+    def [](key)
+      r = super( key ) || super( key.to_sym ) || super( key.to_s  )
+      transform_entry( key, r )
+    end
+
+    def method_missing(sym, *args, &blk)
+      type = sym.to_s[-1,1]
+      name = sym.to_s.gsub(/[=!?]$/, '').to_sym
+      case type
+      when '='
+        self[name] = args.first
+      when '!'
+        __send__(name, *args, &blk)
+      when '?'
+        self[name]
+      else
+        if key?(name)
+          self[name]
+        elsif @cascade_for_nils
+          self[name] = AStruct.new.cascade_for_nils! 
+          self[name]
+        else
+          nil
+        end
+      end
+    end
+
+    UNTRACKED_KEYS = [
+      :url,
+    ]
+
+    def transform_entry(for_key, entry)
+      r = case(entry)
+        when AStructMixin
+          entry
+        when Hash
+          #AStruct.new( entry )
+          entry.extend( AStructMixin )
+        when Array
+          entry.map!{|i| transform_entry( for_key, i)}
+        else
+          entry
+      end
+      if ( self.is_a? Awestruct::Page )
+        unless UNTRACKED_KEYS.include? for_key.to_sym
+          Awestruct::Dependencies.track_dependency( self )
+        end
+      end
+      r
+    end
+
+    def inspect
+      "AStruct{...}"
+    end
+  
+  end
+
+end

data/lib/awestruct/cli/auto.rb

@@ -0,0 +1,34 @@
+require 'guard/awestruct'
+
+module Awestruct
+  module CLI
+    class Auto
+
+      def initialize(config)
+        @config = config
+      end
+
+      def run()
+        Guard.setup
+        Guard.start( :guardfile_contents=>guardfile_contents,
+                     :watchdir=>@config.dir,
+                     :watch_all_modifications=>true )
+      end
+
+      def guardfile_contents
+        ignored = [ 
+          "'.awestruct'",
+          "'#{File.basename( @config.tmp_dir )}'",
+          "'#{File.basename( @config.output_dir )}'",
+        ] 
+        c = ''
+        c += "guard :awestruct do\n"
+        c += "  watch %r(.*)\n"
+        c += "  ignore_paths #{ignored.join(', ')}"
+        c += "end\n"
+        c
+      end
+    end
+
+  end
+end

data/lib/awestruct/cli/deploy.rb

@@ -0,0 +1,38 @@
+require 'awestruct/deploy/rsync_deploy'
+require 'awestruct/deploy/github_pages_deploy'
+
+module Awestruct
+  module CLI
+
+    class Deploy
+
+      attr_accessor :site_config
+      attr_accessor :deploy_config
+
+       def initialize(site_config, deploy_config)
+        @site_config   = site_config
+        @deploy_config = deploy_config
+      end
+  
+      def run()
+        deploy_type = :rsync
+  
+        if ( deploy_config['host'] == 'github_pages' )
+          deploy_type = :github_pages
+        end
+  
+        deployer_class = Awestruct::Deployers.instance[ deploy_type ]
+  
+        if ( deployer_class.nil? )
+          $stderr.puts "Unable to locate correct deployer for #{deploy_type}"
+          return
+        end
+  
+        deployer = deployer_class.new( site_config, deploy_config )
+        deployer.run
+        
+      end
+    end
+
+  end
+end