pancake 0.2.0 → 0.3.0

data/lib/pancake/{generators/templates/micro/%stack_name%/Rakefile.tt → vendor/hashie/Rakefile}

@@ -1,11 +1,5 @@
 require 'rubygems'
 require 'rake'
-require 'pancake'
-
-require File.join(Pancake.get_root(__FILE__), "<%= stack_name %>")
-Pancake.root = Pancake.get_root(__FILE__)
-THIS_STACK = <%= stack_name.camel_case %>
-<%= stack_name.camel_case %>.load_rake_tasks!(:master => true)
 
 require 'spec/rake/spectask'
 Spec::Rake::SpecTask.new(:spec) do |spec|
@@ -19,22 +13,18 @@ Spec::Rake::SpecTask.new(:rcov) do |spec|
   spec.rcov = true
 end
 
-
 task :default => :spec
 
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION.yml')
-    config = YAML.load(File.read('VERSION.yml'))
-    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
   else
     version = ""
   end
 
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "foo #{version}"
+  rdoc.title = "hashie #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
-
-

data/lib/pancake/vendor/hashie/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/pancake/vendor/hashie/hashie.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require 'bundler'
+
+Gem::Specification.new do |s|
+  s.name = %q{hashie}
+  s.version = File.read("VERSION")
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Bleigh"]
+  s.date = %q{2010-03-05}
+  s.description = %q{Hashie is a small collection of tools that make hashes more powerful. Currently includes Mash (Mocking Hash) and Dash (Discrete Hash).}
+  s.email = %q{michael@intridea.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = Dir["**/*"]
+  s.add_bundler_dependencies
+  s.homepage = %q{http://github.com/intridea/hashie}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Your friendly neighborhood hash toolkit.}
+  s.test_files = [
+    "spec/hashie/clash_spec.rb",
+     "spec/hashie/dash_spec.rb",
+     "spec/hashie/hash_spec.rb",
+     "spec/hashie/mash_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+end
+

data/lib/pancake/vendor/hashie/lib/hashie.rb

@@ -0,0 +1,5 @@
+require 'hashie/hash_extensions'
+require 'hashie/hash'
+require 'hashie/mash'
+require 'hashie/dash'
+require 'hashie/clash'

data/lib/pancake/vendor/hashie/lib/hashie/clash.rb

@@ -0,0 +1,86 @@
+require 'hashie/hash'
+
+module Hashie
+  #
+  # A Clash is a "Chainable Lazy Hash". Inspired by libraries such as Arel,
+  # a Clash allows you to chain together method arguments to build a 
+  # hash, something that's especially useful if you're doing something
+  # like constructing a complex options hash. Here's a basic example:
+  # 
+  #     c = Hashie::Clash.new.conditions(:foo => 'bar').order(:created_at)
+  #     c # => {:conditions => {:foo => 'bar'}, :order => :created_at}
+  #
+  # Clash provides another way to create sub-hashes by using bang notation.
+  # You can dive into a sub-hash by providing a key with a bang and dive
+  # back out again with the _end! method. Example:
+  #
+  #     c = Hashie::Clash.new.conditions!.foo('bar').baz(123)._end!.order(:created_at)
+  #     c # => {:conditions => {:foo => 'bar', :baz => 123}, :order => :created_at}
+  #
+  # Because the primary functionality of Clash is to build options objects,
+  # all keys are converted to symbols since many libraries expect symbols explicitly
+  # for keys.
+  #
+  class Clash < ::Hash
+    class ChainError < ::StandardError; end
+    # The parent Clash if this Clash was created via chaining.
+    attr_reader :_parent
+    
+    # Initialize a new clash by passing in a Hash to
+    # convert and, optionally, the parent to which this
+    # Clash is chained.
+    def initialize(other_hash = {}, parent = nil)
+      @_parent = parent
+      other_hash.each_pair do |k, v|
+        self[k.to_sym] = v
+      end
+    end
+    
+    # Jump back up a level if you are using bang method
+    # chaining. For example:
+    #
+    # c = Hashie::Clash.new.foo('bar')
+    # c.baz!.foo(123) # => c[:baz]
+    # c.baz!._end! # => c
+    def _end!
+      self._parent
+    end
+    
+    def id(*args) #:nodoc:
+      method_missing(:id, *args)
+    end
+    
+    def merge_store(key, *args) #:nodoc:
+      case args.length
+        when 1
+          val = args.first
+          val = self[key].merge(val) if self[key].is_a?(::Hash) && val.is_a?(::Hash)
+        else
+          val = args
+      end
+
+      self[key.to_sym] = val
+      self
+    end
+    
+    def method_missing(name, *args) #:nodoc:
+      name = name.to_s
+      if name.match(/!$/) && args.empty?
+        key = name[0...-1].to_sym
+        
+        if self[key].nil?
+          self[key] = Clash.new({}, self)
+        elsif self[key].is_a?(::Hash) && !self[key].is_a?(Clash)
+          self[key] = Clash.new(self[key], self)
+        else
+          raise ChainError, "Tried to chain into a non-hash key."
+        end
+        
+        self[key]
+      elsif args.any?
+        key = name.to_sym
+        self.merge_store(key, *args)
+      end
+    end
+  end
+end

data/lib/pancake/vendor/hashie/lib/hashie/dash.rb

@@ -0,0 +1,108 @@
+require 'hashie/hash'
+
+module Hashie
+  include Hashie::PrettyInspect
+  # A Dash is a 'defined' or 'discrete' Hash, that is, a Hash
+  # that has a set of defined keys that are accessible (with
+  # optional defaults) and only those keys may be set or read.
+  #
+  # Dashes are useful when you need to create a very simple
+  # lightweight data object that needs even fewer options and
+  # resources than something like a DataMapper resource.
+  #
+  # It is preferrable to a Struct because of the in-class
+  # API for defining properties as well as per-property defaults.
+  class Dash < Hashie::Hash
+    include Hashie::PrettyInspect
+    alias_method :to_s, :inspect
+
+    # Defines a property on the Dash. Options are
+    # as follows:
+    #
+    # * <tt>:default</tt> - Specify a default value for this property,
+    #   to be returned before a value is set on the property in a new
+    #   Dash.
+    #
+    def self.property(property_name, options = {})
+      property_name = property_name.to_sym
+
+      (@properties ||= []) << property_name
+      (@defaults ||= {})[property_name] = options.delete(:default)
+
+      class_eval <<-RUBY
+        def #{property_name}
+          self[:#{property_name}]
+        end
+
+        def #{property_name}=(val)
+          self[:#{property_name}] = val
+        end
+      RUBY
+    end
+
+    # Get a String array of the currently defined
+    # properties on this Dash.
+    def self.properties
+      properties = []
+      ancestors.each do |elder| 
+        if elder.instance_variable_defined?("@properties")
+          properties << elder.instance_variable_get("@properties")
+        end
+      end
+
+      properties.flatten.map{|p| p.to_s}
+    end
+
+    # Check to see if the specified property has already been
+    # defined.
+    def self.property?(prop)
+      properties.include?(prop.to_s)
+    end
+
+    # The default values that have been set for this Dash
+    def self.defaults
+      properties = {}
+      ancestors.each do |elder|
+        if elder.instance_variable_defined?("@defaults")
+          properties.merge! elder.instance_variable_get("@defaults")
+        end
+      end
+      
+      properties
+    end
+
+    # You may initialize a Dash with an attributes hash
+    # just like you would many other kinds of data objects.
+    def initialize(attributes = {})
+      self.class.properties.each do |prop|
+        self.send("#{prop}=", self.class.defaults[prop.to_sym])
+      end
+
+      attributes.each_pair do |att, value|
+        self.send("#{att}=", value)
+      end
+    end
+
+    # Retrieve a value from the Dash (will return the
+    # property's default value if it hasn't been set).
+    def [](property)
+      super(property.to_sym) if property_exists? property
+    end
+
+    # Set a value on the Dash in a Hash-like way. Only works
+    # on pre-existing properties.
+    def []=(property, value)
+      super if property_exists? property
+    end
+    
+    private 
+      # Raises an NoMethodError if the property doesn't exist
+      #
+      def property_exists?(property)
+        unless self.class.property?(property.to_sym)
+          raise NoMethodError, "The property '#{property}' is not defined for this Dash."
+        end
+        true
+      end
+  end
+end

data/lib/pancake/vendor/hashie/lib/hashie/hash.rb

@@ -0,0 +1,22 @@
+module Hashie
+  # A Hashie Hash is simply a Hash that has convenience
+  # functions baked in such as stringify_keys that may
+  # not be available in all libraries.
+  class Hash < Hash
+    include Hashie::HashExtensions
+
+    # Converts a mash back to a hash (with stringified keys)
+    def to_hash
+      out = {}
+      keys.each do |k|
+        out[k] = Hashie::Hash === self[k] ? self[k].to_hash : self[k]
+      end
+      out
+    end
+
+    # The C geneartor for the json gem doesn't like mashies
+    def to_json(*args)
+      to_hash.to_json(*args)
+    end
+  end
+end

data/lib/pancake/vendor/hashie/lib/hashie/hash_extensions.rb

@@ -0,0 +1,49 @@
+module Hashie
+  module HashExtensions
+    def self.included(base)
+      # Don't tread on existing extensions of Hash by
+      # adding methods that are likely to exist.
+      %w(stringify_keys stringify_keys!).each do |hashie_method|
+        base.send :alias_method, hashie_method, "hashie_#{hashie_method}" unless base.instance_methods.include?(hashie_method)
+      end
+    end
+
+    # Destructively convert all of the keys of a Hash
+    # to their string representations.
+    def hashie_stringify_keys!
+      self.keys.each do |k|
+        unless String === k
+          self[k.to_s] = self.delete(k)
+        end
+      end
+      self
+    end
+
+    # Convert all of the keys of a Hash
+    # to their string representations.
+    def hashie_stringify_keys
+      self.dup.stringify_keys!
+    end
+
+    # Convert this hash into a Mash
+    def to_mash
+      Hashie::Mash.new(self)
+    end
+  end
+
+  module PrettyInspect
+    def self.included(base)
+      base.send :alias_method, :hash_inspect, :inspect
+      base.send :alias_method, :inspect, :hashie_inspect
+    end
+
+    def hashie_inspect
+      ret = "<##{self.class.to_s}"
+      stringify_keys.keys.sort.each do |key|
+        ret << " #{key}=#{self[key].inspect}"
+      end
+      ret << ">"
+      ret
+    end
+  end
+end

data/lib/pancake/vendor/hashie/lib/hashie/mash.rb

@@ -0,0 +1,148 @@
+module Hashie
+  # Mash allows you to create pseudo-objects that have method-like
+  # accessors for hash keys. This is useful for such implementations
+  # as an API-accessing library that wants to fake robust objects
+  # without the overhead of actually doing so. Think of it as OpenStruct
+  # with some additional goodies.
+  #
+  # A Mash will look at the methods you pass it and perform operations
+  # based on the following rules:
+  #
+  # * No punctuation: Returns the value of the hash for that key, or nil if none exists.
+  # * Assignment (<tt>=</tt>): Sets the attribute of the given method name.
+  # * Existence (<tt>?</tt>): Returns true or false depending on whether that key has been set.
+  # * Bang (<tt>!</tt>): Forces the existence of this key, used for deep Mashes. Think of it as "touch" for mashes.
+  #
+  # == Basic Example
+  #
+  #   mash = Mash.new
+  #   mash.name? # => false
+  #   mash.name = "Bob"
+  #   mash.name # => "Bob"
+  #   mash.name? # => true
+  #
+  # == Hash Conversion  Example
+  #
+  #   hash = {:a => {:b => 23, :d => {:e => "abc"}}, :f => [{:g => 44, :h => 29}, 12]}
+  #   mash = Mash.new(hash)
+  #   mash.a.b # => 23
+  #   mash.a.d.e # => "abc"
+  #   mash.f.first.g # => 44
+  #   mash.f.last # => 12
+  #
+  # == Bang Example
+  #
+  #   mash = Mash.new
+  #   mash.author # => nil
+  #   mash.author! # => <Mash>
+  #
+  #   mash = Mash.new
+  #   mash.author!.name = "Michael Bleigh"
+  #   mash.author # => <Mash name="Michael Bleigh">
+  #
+  class Mash < Hashie::Hash
+    include Hashie::PrettyInspect
+    alias_method :to_s, :inspect
+
+    # If you pass in an existing hash, it will
+    # convert it to a Mash including recursively
+    # descending into arrays and hashes, converting
+    # them as well.
+    def initialize(source_hash = nil, default = nil, &blk)
+      deep_update(source_hash) if source_hash
+      default ? super(default) : super(&blk)
+    end
+
+    class << self; alias [] new; end
+
+    def id #:nodoc:
+      key?("id") ? self["id"] : super
+    end
+
+    alias_method :regular_reader, :[]
+    alias_method :regular_writer, :[]=
+
+    # Retrieves an attribute set in the Mash. Will convert
+    # any key passed in to a string before retrieving.
+    def [](key)
+      regular_reader(convert_key(key))
+    end
+
+    # Sets an attribute in the Mash. Key will be converted to
+    # a string before it is set, and Hashes will be converted
+    # into Mashes for nesting purposes.
+    def []=(key,value) #:nodoc:
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # This is the bang method reader, it will return a new Mash
+    # if there isn't a value already assigned to the key requested.
+    def initializing_reader(key)
+      ck = convert_key(key)
+      regular_writer(ck, Hashie::Mash.new) unless key?(ck)
+      regular_reader(ck)
+    end
+
+    alias_method :regular_dup, :dup
+    # Duplicates the current mash as a new mash.
+    def dup
+      Mash.new(self, self.default)
+    end
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    # Performs a deep_update on a duplicate of the
+    # current mash.
+    def deep_merge(other_hash)
+      dup.deep_merge!(other_hash)
+    end
+
+    # Recursively merges this mash with the passed
+    # in hash, merging each hash in the hierarchy.
+    def deep_update(other_hash)
+      other_hash.each_pair do |k,v|
+        regular_writer(convert_key(k), convert_value(other_hash[k], true))
+      end
+      self
+    end
+    alias_method :deep_merge!, :deep_update
+    alias_method :update, :deep_update
+    alias_method :merge!, :update
+
+
+   def method_missing(method_name, *args, &blk)
+     return self[method_name] if key?(method_name)
+     match = method_name.to_s.match(/(.*?)([?=!]?)$/)
+     case match[2]
+     when "="
+       self[match[1]] = args.first
+     when "?"
+       key?(match[1])
+     when "!"
+       initializing_reader(match[1])
+     else
+       default(method_name, *args, &blk)
+     end
+   end
+
+    protected
+
+    def convert_key(key) #:nodoc:
+      key.to_s
+    end
+
+    def convert_value(val, duping=false) #:nodoc:
+      case val
+        when ::Hash
+          val = val.dup if duping
+          self.class.new(val)
+        when Array
+          val.collect{ |e| convert_value(e) }
+        else
+          val
+      end
+    end
+  end
+end