chozo 0.2.3 → 0.3.0

data/chozo.gemspec

@@ -7,6 +7,7 @@ Gem::Specification.new do |s|
   s.description   = %q{A collection of supporting libraries and Ruby core extensions}
   s.summary       = s.description
   s.homepage      = "https://github.com/reset/chozo"
+  s.license       = "Apache 2.0"
 
   s.files         = `git ls-files`.split($\)
   s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/lib/chozo/config/abstract.rb

@@ -1,4 +1,3 @@
-require 'forwardable'
 require 'chozo/varia_model'
 
 module Chozo
@@ -6,10 +5,15 @@ module Chozo
     # @author Jamie Winsor <jamie@vialstudios.com>
     # @api private
     class Abstract
+      extend Forwardable
       include VariaModel
       
       attr_accessor :path
 
+      def_delegator :to_hash, :slice
+      def_delegator :to_hash, :slice!
+      def_delegator :to_hash, :extract!
+
       # @param [String] path
       # @param [Hash] attributes
       def initialize(path = nil, attributes = {})
@@ -26,6 +30,10 @@ module Chozo
         self.attributes[key] = value
       end
 
+      def to_hash
+        self.attributes.to_hash.deep_symbolize_keys
+      end
+
       protected
 
         def mass_assign(new_attributes = {})

data/lib/chozo/config/json.rb

@@ -22,7 +22,7 @@ module Chozo
           path = File.expand_path(path)
           data = File.read(path)
           new(path).from_json(data)
-        rescue Errno::ENOENT, Errno::EISDIR
+        rescue TypeError, Errno::ENOENT, Errno::EISDIR
           raise Chozo::Errors::ConfigNotFound, "No configuration found at: '#{path}'"
         end
       end
@@ -58,6 +58,14 @@ module Chozo
           f.write(self.to_json(pretty: true))
         end
       end
+
+      # Reload the current configuration file from disk
+      #
+      # @return [Chozo::Config::JSON]
+      def reload
+        mass_assign(self.class.from_file(path).attributes)
+        self
+      end
     end
   end
 end

data/lib/chozo/core_ext/hash.rb

@@ -1,110 +1,2 @@
-class Hash
-  class << self
-    # Create a new Hash containing other nested Hashes from a string containing
-    # a dotted path. A Hash will be created and assigned to a key of another Hash
-    # for each entry in the dotted path.
-    #
-    # If a value is provided for the optional seed argument then the value of the
-    # deepest nested key will be set to the given value. If no value is provided
-    # the value of the key will be nil.
-    #
-    # @example creating a nested hash from a dotted path
-    #
-    #   Hash.from_dotted_path("deep.nested.hash") =>
-    #   {
-    #     "deep" => {
-    #       "nested" => {
-    #         "hash" => nil
-    #       }
-    #     }
-    #   }
-    #
-    #
-    # @example specifying a seed value
-    #
-    #   Hash.from_dotted_path("deep.nested.hash", :seed_value) =>
-    #   {
-    #     "deep" => {
-    #       "nested" => {
-    #         "hash" => :seed_value
-    #       }
-    #     }
-    #   }
-    #
-    # @param [String, Array] dotpath
-    # @param [Object] seed
-    # @param [Hash] target
-    #
-    # @return [Hash]
-    def from_dotted_path(dotpath, seed = nil, target = self.new)
-      case dotpath
-      when String
-        from_dotted_path(dotpath.split("."), seed)
-      when Array
-        if dotpath.empty?
-          return target
-        end
-
-        key = dotpath.pop
-
-        if target.empty?
-          target[key] = seed
-          from_dotted_path(dotpath, seed, target)
-        else
-          new_target = self.new
-          new_target[key] = target
-          from_dotted_path(dotpath, seed, new_target)
-        end
-      end
-    end
-  end
-
-  # Return the value of the nested hash key from the given dotted path
-  #
-  # @example
-  #
-  #   nested_hash = {
-  #     "deep" => {
-  #       "nested" => {
-  #         "hash" => :seed_value
-  #       }
-  #     }
-  #   }
-  #
-  #   nested_hash.dig('deep.nested.hash') => :seed_value
-  #
-  # @param [String] path
-  #
-  # @return [Object, nil]
-  def dig(path)
-    parts = path.split('.', 2)
-    match = (self[parts[0].to_s] || self[parts[0].to_sym])
-    if !parts[1] or match.nil?
-      match
-    else
-      match.dig(parts[1])
-    end
-  end
-
-  # Returns an array of dotted paths from the keys, values of this Hash. Values which are
-  # nested Hashes will also recurred into and their paths will be added properly.
-  #
-  # @param [Hash] source
-  # @param [Array] acc
-  # @param [Array] namespace
-  #
-  # @return [Array<String>]
-  def dotted_paths(source = self, acc = Array.new, namespace = Array.new)
-    if source.is_a?(Hash)
-      source.each do |key, value|
-        branch = namespace.dup
-        branch << key
-        dotted_paths(value, acc, branch)
-      end
-    else
-      acc << namespace.join('.')
-    end
-
-    acc
-  end
-end
+require 'chozo/core_ext/hash/keys'
+require 'chozo/core_ext/hash/dotted_paths'

data/lib/chozo/core_ext/hash/dotted_paths.rb

@@ -0,0 +1,110 @@
+class Hash
+  class << self
+    # Create a new Hash containing other nested Hashes from a string containing
+    # a dotted path. A Hash will be created and assigned to a key of another Hash
+    # for each entry in the dotted path.
+    #
+    # If a value is provided for the optional seed argument then the value of the
+    # deepest nested key will be set to the given value. If no value is provided
+    # the value of the key will be nil.
+    #
+    # @example creating a nested hash from a dotted path
+    #
+    #   Hash.from_dotted_path("deep.nested.hash") =>
+    #   {
+    #     "deep" => {
+    #       "nested" => {
+    #         "hash" => nil
+    #       }
+    #     }
+    #   }
+    #
+    #
+    # @example specifying a seed value
+    #
+    #   Hash.from_dotted_path("deep.nested.hash", :seed_value) =>
+    #   {
+    #     "deep" => {
+    #       "nested" => {
+    #         "hash" => :seed_value
+    #       }
+    #     }
+    #   }
+    #
+    # @param [String, Array] dotpath
+    # @param [Object] seed
+    # @param [Hash] target
+    #
+    # @return [Hash]
+    def from_dotted_path(dotpath, seed = nil, target = self.new)
+      case dotpath
+      when String
+        from_dotted_path(dotpath.split("."), seed)
+      when Array
+        if dotpath.empty?
+          return target
+        end
+
+        key = dotpath.pop
+
+        if target.empty?
+          target[key] = seed
+          from_dotted_path(dotpath, seed, target)
+        else
+          new_target = self.new
+          new_target[key] = target
+          from_dotted_path(dotpath, seed, new_target)
+        end
+      end
+    end
+  end
+
+  # Return the value of the nested hash key from the given dotted path
+  #
+  # @example
+  #
+  #   nested_hash = {
+  #     "deep" => {
+  #       "nested" => {
+  #         "hash" => :seed_value
+  #       }
+  #     }
+  #   }
+  #
+  #   nested_hash.dig('deep.nested.hash') => :seed_value
+  #
+  # @param [String] path
+  #
+  # @return [Object, nil]
+  def dig(path)
+    parts = path.split('.', 2)
+    match = (self[parts[0].to_s] || self[parts[0].to_sym])
+    if !parts[1] or match.nil?
+      match
+    else
+      match.dig(parts[1])
+    end
+  end
+
+  # Returns an array of dotted paths from the keys, values of this Hash. Values which are
+  # nested Hashes will also recurred into and their paths will be added properly.
+  #
+  # @param [Hash] source
+  # @param [Array] acc
+  # @param [Array] namespace
+  #
+  # @return [Array<String>]
+  def dotted_paths(source = self, acc = Array.new, namespace = Array.new)
+    if source.is_a?(Hash)
+      source.each do |key, value|
+        branch = namespace.dup
+        branch << key
+        dotted_paths(value, acc, branch)
+      end
+    else
+      acc << namespace.join('.')
+    end
+
+    acc
+  end
+end

data/lib/chozo/core_ext/hash/keys.rb

@@ -0,0 +1,141 @@
+# https://raw.github.com/rails/rails/master/activesupport/lib/active_support/core_ext/hash/keys.rb
+#
+# Replace with ActiveSupport 4.0 when released
+class Hash
+  # Return a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => { "NAME" => "Rob", "AGE" => "28" }
+  def transform_keys
+    result = {}
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively convert all keys using the block operations.
+  # Same as transform_keys but modifies +self+.
+  def transform_keys!
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   #=> { "name" => "Rob", "age" => "28" }
+  def stringify_keys
+    transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!{ |key| key.to_s }
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   #=> { name: "Rob", age: "28" }
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options,  :symbolize_keys
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys!{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising ArgumentError
+  # on a mismatch. Note that keys are NOT treated indifferently, meaning if you
+  # use strings for keys but assert symbols as keys, this will fail.
+  #
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: years"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: name"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      raise ArgumentError.new("Unknown key: #{k}") unless valid_keys.include?(k)
+    end
+  end
+
+  # Return a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => { "PERSON" => { "NAME" => "Rob", "AGE" => "28" } }
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+
+  # Destructively convert all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_transform_keys!(&block)
+    keys.each do |key|
+      value = delete(key)
+      self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => { "person" => { "name" => "Rob", "age" => "28" } }
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_stringify_keys!
+    deep_transform_keys!{ |key| key.to_s }
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => { person: { name: "Rob", age: "28" } }
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
+  end
+end

data/lib/chozo/hashie_ext/hash.rb

@@ -0,0 +1,9 @@
+module Hashie
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class Hash < ::Hash
+    # Ensure we always symbolize keys when calling #to_hash
+    def to_hash
+      super.deep_symbolize_keys
+    end
+  end
+end

data/lib/chozo/version.rb

@@ -1,3 +1,3 @@
 module Chozo
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/spec/unit/chozo/config/abstract_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Chozo::Config::Abstract do
+  subject { Class.new(described_class).new }
+
+  describe "#to_hash" do
+    it "returns a Hash" do
+      subject.to_hash.should be_a(Hash)
+    end
+
+    it "contains all of the attributes" do
+      subject.attributes[:something] = "value"
+      
+      subject.to_hash.should have_key(:something)
+      subject.to_hash[:something].should eql("value")
+    end
+  end
+
+  describe "#slice" do
+    before(:each) do
+      subject.attributes[:one] = {
+        nested: "value"
+      }
+      subject.attributes[:two] = {
+        nested: "other"
+      }
+      @sliced = subject.slice(:one)
+    end
+
+    it "returns a Hash" do
+      @sliced.should be_a(Hash)
+    end
+
+    it "contains just the sliced elements" do
+      @sliced.should have(1).item
+    end
+  end
+end

data/spec/unit/chozo/config/json_spec.rb

@@ -102,4 +102,33 @@ describe Chozo::Config::JSON do
       }.should raise_error(Chozo::Errors::ConfigSaveError)
     end
   end
+
+  describe "#reload" do
+    before(:each) do
+      subject.path = tmp_path.join('tmpconfig.json').to_s
+      subject.save
+    end
+
+    it "returns self" do
+      subject.reload.should eql(subject)
+    end
+
+    it "updates the contents of self from disk" do
+      original = subject.class.from_file(subject.path)
+      subject.job = "programmer"
+      subject.save
+
+      original.job.should be_nil
+      original.reload
+      original.job.should eql("programmer")
+    end
+
+    it "raises ConfigNotFound if the path is nil" do
+      subject.path = nil
+
+      expect {
+        subject.reload.should eql(subject)
+      }.to raise_error(Chozo::Errors::ConfigNotFound)
+    end
+  end
 end

data/spec/unit/chozo/varia_model_spec.rb

@@ -212,7 +212,7 @@ describe Chozo::VariaModel do
         subject.validate_required(model, key).first.should eql(:error)
       end
 
-      it "passes validation if the value of the attribute is false", focus: true do
+      it "passes validation if the value of the attribute is false" do
         model.set_attribute(key, false)
 
         subject.validate_required(model, key).first.should eql(:ok)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chozo
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-14 00:00:00.000000000 Z
+date: 2012-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -82,10 +82,13 @@ files:
 - lib/chozo/core_ext.rb
 - lib/chozo/core_ext/boolean.rb
 - lib/chozo/core_ext/hash.rb
+- lib/chozo/core_ext/hash/dotted_paths.rb
+- lib/chozo/core_ext/hash/keys.rb
 - lib/chozo/core_ext/kernel.rb
 - lib/chozo/core_ext/set.rb
 - lib/chozo/errors.rb
 - lib/chozo/hashie_ext.rb
+- lib/chozo/hashie_ext/hash.rb
 - lib/chozo/hashie_ext/mash.rb
 - lib/chozo/platform.rb
 - lib/chozo/ruby_engine.rb
@@ -95,13 +98,15 @@ files:
 - spec/spec_helper.rb
 - spec/support/helpers.rb
 - spec/support/matchers/each.rb
+- spec/unit/chozo/config/abstract_spec.rb
 - spec/unit/chozo/config/json_spec.rb
 - spec/unit/chozo/core_ext/hash_spec.rb
 - spec/unit/chozo/platform_spec.rb
 - spec/unit/chozo/ruby_engine_spec.rb
 - spec/unit/chozo/varia_model_spec.rb
 homepage: https://github.com/reset/chozo
-licenses: []
+licenses:
+- Apache 2.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -120,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 23954185641818190
+      hash: 3239723575146630686
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -132,6 +137,7 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/helpers.rb
 - spec/support/matchers/each.rb
+- spec/unit/chozo/config/abstract_spec.rb
 - spec/unit/chozo/config/json_spec.rb
 - spec/unit/chozo/core_ext/hash_spec.rb
 - spec/unit/chozo/platform_spec.rb