Move CLI into middleman-cli

middleman-core/lib/middleman-core/util.rb

@@ -46,10 +46,10 @@ module Middleman
       #
       # @private
       # @param [Hash] data Normal hash
-      # @return [Thor::CoreExt::HashWithIndifferentAccess]
+      # @return [Middleman::Util::HashWithIndifferentAccess]
       def recursively_enhance(data)
         if data.is_a? Hash
-          data = ::Thor::CoreExt::HashWithIndifferentAccess.new(data)
+          data = ::Middleman::Util::HashWithIndifferentAccess.new(data)
           data.each do |key, val|
             data[key] = recursively_enhance(val)
           end
@@ -217,7 +217,7 @@ module Middleman
         end
       end
 
-    private
+      private
 
       # Is mime type known to be non-binary?
       #
@@ -277,5 +277,81 @@ module Middleman
         end
       end
     end
+  
+    # A hash with indifferent access and magic predicates.
+    # Copied from Thor
+    #
+    #   hash = Middleman::Application.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+    #
+    #   hash[:foo]  #=> 'bar'
+    #   hash['foo'] #=> 'bar'
+    #   hash.foo?   #=> true
+    #
+    class HashWithIndifferentAccess < ::Hash #:nodoc:
+
+      def initialize(hash={})
+        super()
+        hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      # Convert to a Hash with String keys.
+      def to_hash
+        Hash.new(default).merge!(self)
+      end
+
+      protected
+
+        def convert_key(key)
+          key.is_a?(Symbol) ? key.to_s : key
+        end
+
+        # Magic predicates. For instance:
+        #
+        #   options.force?                  # => !!options['force']
+        #   options.shebang                 # => "/usr/lib/local/ruby"
+        #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+        #
+        def method_missing(method, *args, &block)
+          method = method.to_s
+          if method =~ /^(\w+)\?$/
+            if args.empty?
+              !!self[$1]
+            else
+              self[$1] == args.first
+            end
+          else
+            self[method]
+          end
+        end
+    end
   end
-end
+end