middleman-core 3.0.14 → 3.1.0.beta.1

data/lib/middleman-core/cli.rb

@@ -39,8 +39,8 @@ module Middleman
           klass.start(["-h", task].compact, :shell => self.shell)
         else
           list = []
-          Thor::Util.thor_classes_in(Middleman::Cli).each do |klass|
-            list += klass.printable_tasks(false)
+          Thor::Util.thor_classes_in(Middleman::Cli).each do |thor_class|
+            list += thor_class.printable_tasks(false)
           end
           list.sort!{ |a,b| a[0] <=> b[0] }
 
@@ -87,3 +87,4 @@ require "middleman-core/cli/bundler"
 require "middleman-core/cli/extension"
 require "middleman-core/cli/server"
 require "middleman-core/cli/build"
+require "middleman-core/cli/console"

data/lib/middleman-core/cli/build.rb

@@ -17,9 +17,8 @@ module Middleman::Cli
     desc "build [options]", "Builds the static site for deployment"
     method_option :clean,
       :type    => :boolean,
-      :aliases => "-c",
-      :default => false,
-      :desc    => 'Removes orphaned files or directories from build'
+      :default => true,
+      :desc    => 'Remove orphaned files from build (--no-clean to disable)'
     method_option :glob,
       :type    => :string,
       :aliases => "-g",
@@ -60,13 +59,12 @@ module Middleman::Cli
 
       opts = {}
       opts[:glob]  = options["glob"]  if options.has_key?("glob")
-      opts[:clean] = options["clean"] if options.has_key?("clean")
+      opts[:clean] = options["clean"]  if options.has_key?("clean")
 
       action GlobAction.new(self, opts)
 
       if @had_errors && !@debugging
         cmd = "middleman build --verbose"
-        cmd = "bundle exec '#{cmd}'" if defined?(Bundler)
         self.shell.say "There were errors during this build, re-run with `#{cmd}` to see the full exception."
       end
 
@@ -86,7 +84,7 @@ module Middleman::Cli
       # @return [Middleman::Application]
       def shared_instance(verbose=false, instrument=false)
         @_shared_instance ||= ::Middleman::Application.server.inst do
-          set :environment, :build
+          config[:environment] = :build
           logger(verbose ? 0 : 1, instrument)
         end
       end
@@ -117,7 +115,7 @@ module Middleman::Cli
       # @param [Middleman::Sitemap::Resource] resource
       # @return [String] The full path of the file that was written
       def render_to_file(resource)
-        build_dir = self.class.shared_instance.build_dir
+        build_dir = self.class.shared_instance.config[:build_dir]
         output_file = File.join(build_dir, resource.destination_path)
 
         if resource.binary?

data/lib/middleman-core/cli/bundler.rb

@@ -12,7 +12,7 @@ module Middleman::Cli
 
     # The setup task
     def bundle
-      run('bundle install --without development test')#, :capture => true)
+      run('bundle install')#, :capture => true)
     end
   end
 

data/lib/middleman-core/cli/console.rb

@@ -0,0 +1,46 @@
+# CLI Module
+module Middleman::Cli
+
+  # A thor task for creating new projects
+  class Console < Thor
+    include Thor::Actions
+
+    check_unknown_options!
+
+    namespace :console
+    
+    desc "console [options]", "Start an interactive console in the context of your Middleman application"
+    method_option :environment,
+      :aliases => "-e",
+      :default => ENV['MM_ENV'] || ENV['RACK_ENV'] || 'development',
+      :desc    => "The environment Middleman will run under"
+    method_option :verbose,
+      :type    => :boolean,
+      :default => false,
+      :desc    => 'Print debug messages'
+    def console
+      require "middleman-core"
+      require "irb"
+
+      opts = {
+        :environment => options['environment'],
+        :debug => options['verbose']
+      }
+
+      @app =::Middleman::Application.server.inst do
+        if opts[:environment]
+          set :environment, opts[:environment].to_sym
+        end
+
+        logger(opts[:debug] ? 0 : 1, opts[:instrumenting] || false)
+      end
+
+      # TODO: get file watcher / reload! working in console
+
+      IRB.setup nil
+      IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+      require 'irb/ext/multi-irb'
+      IRB.irb nil, @app
+    end
+  end
+end

data/lib/middleman-core/configuration.rb

@@ -0,0 +1,235 @@
+module Middleman
+  module Configuration
+    # Access to a global configuration manager for the whole Middleman project, 
+    # plus backwards compatibility mechanisms for older Middleman projects.
+    module Global
+      def self.included(app)
+        app.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        # Global configuration for the whole Middleman project.
+        # @return [ConfigurationManager]
+        def config
+          @_config ||= ConfigurationManager.new
+        end
+
+        # Set attributes (global variables)
+        #
+        # @deprecated Prefer accessing settings through "config".
+        #
+        # @param [Symbol] key Name of the attribue
+        # @param default Attribute value
+        # @return [void]
+        def set(key, default=nil, &block)
+          config.define_setting(key, default)
+          @inst.set(key, default, &block) if @inst
+        end
+
+        # Access global settings as methods, to preserve compatibility with
+        # old Middleman.
+        #
+        # @deprecated Prefer accessing settings through "config".
+        def method_missing(method, *args)
+          if config.defines_setting? method
+            config[method]
+          else
+            super
+          end
+        end
+
+        # Needed so that method_missing makes sense
+        def respond_to?(method, include_private = false)
+          super || config.defines_setting?(method)
+        end
+      end
+
+      def config
+        self.class.config
+      end
+
+      # Backwards compatibilty with old Sinatra template interface
+      #
+      # @deprecated Prefer accessing settings through "config".
+      #
+      # @return [ConfigurationManager]
+      alias :settings :config
+
+      # Set attributes (global variables)
+      #
+      # @deprecated Prefer accessing settings through "config".
+      #
+      # @param [Symbol] key Name of the attribue
+      # @param value Attribute value
+      # @return [void]
+      def set(key, value=nil, &block)
+        value = block if block_given?
+        config[key] = value
+      end
+
+      # Access global settings as methods, to preserve compatibility with
+      # old Middleman.
+      #
+      # @deprecated Prefer accessing settings through "config".
+      def method_missing(method, *args)
+        if config.defines_setting? method
+          config[method]
+        else
+          super
+        end
+      end
+
+      # Needed so that method_missing makes sense
+      def respond_to?(method, include_private = false)
+        super || config.defines_setting?(method)
+      end
+    end
+
+    # A class that manages a collection of documented settings.
+    # Can be used by extensions as well as the main Middleman
+    # application. Extensions should probably finalize their instance
+    # after defining all the settings they want to expose.
+    class ConfigurationManager
+      def initialize
+        # A hash from setting key to ConfigSetting instance.
+        @settings = {}
+        @finalized = false
+      end
+
+      # Get all settings, sorted by key, as ConfigSetting objects.
+      # @return [Array<ConfigSetting>]
+      def all_settings
+        @settings.values.sort_by(&:key)
+      end
+
+      # Get a full ConfigSetting object for the setting with the give key.
+      # @return [ConfigSetting]
+      def setting(key)
+        @settings[key]
+      end
+
+      # Get the value of a setting by key. Returns nil if there is no such setting.
+      # @return [Object]
+      def [](key)
+        setting = @settings[key]
+        setting ? setting.value : nil
+      end
+
+      # Set the value of a setting by key. Creates the setting if it doesn't exist.
+      # @param [Symbol] key
+      # @param [Object] val
+      def []=(key, val)
+        setting = @settings[key] || define_setting(key)
+        setting.value = val
+      end
+
+      # Allow configuration settings to be read and written via methods
+      def method_missing(method, *args)
+        if defines_setting?(method) && args.size == 0
+          self[method]
+        elsif method =~ /^(\w+)=$/ && args.size == 1
+          self[$1.to_sym] = args[0]
+        else
+          super
+        end
+      end
+
+      # Needed so that method_missing makes sense
+      def respond_to?(method, include_private = false)
+        super || defines_setting?(method) || (method =~ /^(\w+)=$/ && defines_setting?($1))
+      end
+
+      # Does this configuration manager know about the setting identified by key?
+      # @param [Symbol] key
+      # @return [Boolean]
+      def defines_setting?(key)
+        @settings.has_key?(key)
+      end
+
+      # Define a new setting, with optional default and user-friendly description.
+      # Once the configuration manager is finalized, no new settings may be defined.
+      #
+      # @param [Symbol] key
+      # @param [Object] default
+      # @param [String] description
+      # @return [ConfigSetting]
+      def define_setting(key, default=nil, description=nil)
+        raise "Setting #{key} doesn't exist" if @finalized
+        raise "Setting #{key} already defined" if @settings.has_key?(key)
+        raise "Setting key must be a Symbol" unless key.is_a? Symbol
+
+        @settings[key] = ConfigSetting.new(key, default, description)
+      end
+
+      # Switch the configuration manager is finalized, it switches to read-only
+      # mode and no new settings may be defined.
+      def finalize!
+        @finalized = true
+        self
+      end
+
+      # Deep duplicate of the configuration manager
+      def dup
+        ConfigurationManager.new.tap {|c| c.load_settings(self.all_settings) }
+      end
+
+      # Load in a list of settings
+      def load_settings(other_settings)
+        other_settings.each do |setting|
+          new_setting = define_setting(setting.key, setting.default, setting.description)
+          new_setting.value = setting.value if setting.value_set?
+        end
+      end
+
+      def to_h
+        hash = {}
+        @settings.each do |key, setting|
+          hash[key] = setting.value
+        end
+        hash
+      end
+
+      def to_s
+        to_h.inspect
+      end
+    end
+
+    # An individual configuration setting, with an optional default and description.
+    # Also models whether or not a value has been set.
+    class ConfigSetting
+      # The name of this setting
+      attr_accessor :key
+
+      # The default value for this setting
+      attr_accessor :default
+
+      # A human-friendly description of the setting
+      attr_accessor :description
+
+      def initialize(key, default, description)
+        @value_set = false
+        self.key = key
+        self.default = default
+        self.description = description
+      end
+
+      # The user-supplied value for this setting, overriding the default
+      def value=(value)
+        @value = value
+        @value_set = true
+      end
+
+      # The effective value of the setting, which may be the default
+      # if the user has not set a value themselves. Note that even if the
+      # user sets the value to nil it will override the default.
+      def value
+        value_set? ? @value : default
+      end
+
+      # Whether or not there has been a value set beyond the default
+      def value_set?
+        @value_set
+      end
+    end
+  end
+end

data/lib/middleman-core/core_extensions.rb

@@ -4,9 +4,6 @@ require "middleman-core/core_extensions/request"
 # File Change Notifier
 require "middleman-core/core_extensions/file_watcher"
 
-# Add Builder callbacks
-require "middleman-core/core_extensions/builder"
-
 # Custom Feature API
 require "middleman-core/core_extensions/extensions"
 
@@ -28,6 +25,3 @@ require "middleman-core/core_extensions/routing"
 
 # Catch and show exceptions at the Rack level
 require "middleman-core/core_extensions/show_exceptions"
-
-# Manage Ruby string encodings
-require "middleman-core/core_extensions/ruby_encoding"

data/lib/middleman-core/core_extensions/data.rb

@@ -13,7 +13,7 @@ module Middleman
           require "yaml"
           require "active_support/json"
 
-          app.set :data_dir, "data"
+          app.config.define_setting :data_dir, "data", "The directory data files are stored in"
           app.send :include, InstanceMethods
         end
         alias :included :registered
@@ -25,11 +25,11 @@ module Middleman
         # parsing config.rb
         def initialize
           self.files.changed DataStore.matcher do |file|
-            self.data.touch_file(file) if file.start_with?("#{self.data_dir}/")
+            self.data.touch_file(file) if file.start_with?("#{config[:data_dir]}/")
           end
 
           self.files.deleted DataStore.matcher do |file|
-            self.data.remove_file(file) if file.start_with?("#{self.data_dir}/")
+            self.data.remove_file(file) if file.start_with?("#{config[:data_dir]}/")
           end
 
           super
@@ -61,7 +61,7 @@ module Middleman
         #
         # @param [Symbol] name Name of the data, used for namespacing
         # @param [Hash] content The content for this data
-        # @return [void]
+        # @return [Hash]
         def store(name=nil, content=nil)
           @_local_sources ||= {}
           @_local_sources[name.to_s] = content unless name.nil? || content.nil?
@@ -72,7 +72,7 @@ module Middleman
         #
         # @param [Symbol] name Name of the data, used for namespacing
         # @param [Proc] proc The callback which will return data
-        # @return [void]
+        # @return [Hash]
         def callbacks(name=nil, proc=nil)
           @_callback_sources ||= {}
           @_callback_sources[name.to_s] = proc unless name.nil? || proc.nil?
@@ -92,19 +92,30 @@ module Middleman
         # @param [String] file The file to be re-parsed
         # @return [void]
         def touch_file(file)
-          file = File.expand_path(file, @app.root)
+          root = Pathname(@app.root)
+          full_path = root + file
           extension = File.extname(file)
           basename  = File.basename(file, extension)
 
+          data_path = full_path.relative_path_from(root + @app.config[:data_dir])
+
           if %w(.yaml .yml).include?(extension)
-            data = YAML.load_file(file)
+            data = YAML.load_file(full_path)
           elsif extension == ".json"
-            data = ActiveSupport::JSON.decode(File.read(file))
+            data = ActiveSupport::JSON.decode(full_path.read)
           else
             return
           end
 
-          @local_data[basename] = ::Middleman::Util.recursively_enhance(data)
+          data_branch = @local_data
+
+          path = data_path.to_s.split(File::SEPARATOR)[0..-2]
+          path.each do |dir|
+            data_branch[dir] ||= ::Middleman::Util.recursively_enhance({})
+            data_branch = data_branch[dir]
+          end
+
+          data_branch[basename] = ::Middleman::Util.recursively_enhance(data)
         end
 
         # Remove a given file from the internal cache
@@ -112,12 +123,24 @@ module Middleman
         # @param [String] file The file to be cleared
         # @return [void]
         def remove_file(file)
+          root = Pathname(@app.root)
+          full_path = root + file
           extension = File.extname(file)
           basename  = File.basename(file, extension)
-          @local_data.delete(basename) if @local_data.has_key?(basename)
+
+          data_path = full_path.relative_path_from(root + @app.config[:data_dir])
+
+          data_branch = @local_data
+
+          path = data_path.to_s.split(File::SEPARATOR)[0..-2]
+          path.each do |dir|
+            data_branch = data_branch[dir]
+          end
+
+          data_branch.delete(basename) if data_branch.has_key?(basename)
         end
 
-        # Get a hash hash from either internal static data or a callback
+        # Get a hash from either internal static data or a callback
         #
         # @param [String, Symbol] path The name of the data namespace
         # @return [Hash, nil]