octothorpe 0.1.0

data/.hgignore

@@ -0,0 +1,13 @@
+syntax: glob
+.bundle
+Gemfile.lock
+doc/
+pkg/
+spec/reports/
+tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.rbenv-gemsets

data/.rspec

@@ -0,0 +1,5 @@
+--color
+--require spec_helper
+--require doc_no_pending
+-I .
+--format progress

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p551

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in octothorpe.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Andy Jones
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# Octothorpe
+
+A very simple hash-like class that borrows a little from OpenStruct, etc.
+
+* Treats string and symbol keys as equal
+* Access member objects with ot.>>.keyname
+* Guard conditions allow you to control what returns if key is not present
+* Pretty much read-only, for better or worse
+
+Meant to facilitate message-passing between classes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'octothorpe'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install octothorpe
+
+## Usage
+
+Simple example:
+
+    ot = Octotghorpe.new(one: 1, "two" => 2, "weird key" => 3)
+    ot.>>.one            # -> 1
+    ot.>>.two            # -> 2
+    ot.get("weird key")  # -> 3
+
+With guard conditions:
+
+    ot = Octotghorpe.new(one: 1, "two" => 2)
+    ot.guard(Array, :three)
+    ot.freeze       # optional step - makes OT truly read-only
+    ot.>>.three     # -> [] 
+    ot.>>.three[9]  # valid (of course; returns nil)
+
+Octothorpe responds to a good subset of the methods that hash does
+(although, not the write methods).
+
+## FAQ
+
+### Octo-what?
+
+An antiquated term for the pound, or, _hash_ key on a phone keyboard. It's a
+sort of a joke, you see. Or, very nearly.
+
+### This is a very small library. Was it really worth it?
+
+Maybe not. Feel free to be your own judge.
+
+### What possible use is it?
+
+If you are fed up with errors caused because Gem A gives you a hash with string
+keys and Gem B expects symbol keys; or you are tired of putting:
+
+    hash && (hash[:key] || {})[4]
+
+...then this might just possibly be of use. 
+
+Alternatively you might try an OpenStruct, Rails' HashWithIndifferentAccess,
+the Hashie gem or the AndAnd gem.
+
+### Why Read-Only?
+
+Functional programming. 
+
+I find it very hard to fully realise the ideals of functional programming in
+Ruby; but as I get closer to those ideals, my code becomes clearer to read and
+my tests become much, much simpler.
+

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+

data/lib/octothorpe.rb

@@ -0,0 +1,195 @@
+# Coding: UTF-8
+
+require 'forwardable'
+
+
+##
+# A very simple hash-like class that borrows a little from OpenStruct, etc.
+#
+# * Treats string and symbol keys as equal
+# * Access member objects with ot.>>.keyname
+# * Guard conditions allow you to control what returns if key is not present
+# * Pretty much read-only, for better or worse
+#
+# Meant to facilitate message-passing between classes.
+#
+# Simple example:
+#     ot = Octotghorpe.new(one: 1, "two" => 2, "weird key" => 3)
+#     ot.>>.one            # -> 1
+#     ot.>>.two            # -> 2
+#     ot.get("weird key")  # -> 3
+#
+# With guard conditions:
+#     ot = Octotghorpe.new(one: 1, "two" => 2)
+#     ot.guard(Array, :three)
+#     ot.freeze       # optional step - makes OT truly read-only
+#     ot.>>.three     # -> [] 
+#     ot.>>.three[9]  # valid (of course; returns nil)
+#
+# Octothorpe additionally responds to the following methods exactly as a Hash
+# would:
+#
+#    empty?, has_key?, has_value?, include?
+#    each,   each_key, each_value, keys,    values
+#    select, map,      reject,     inject
+#
+class Octothorpe
+  extend Forwardable
+
+  def_delegators :@inner_hash, :empty?, :has_key?, :has_value?, :include?
+  def_delegators :@inner_hash, :each, :each_key, :each_value, :keys, :values
+  def_delegators :@inner_hash, :select, :map, :reject, :inject
+
+  # Gem version number
+  VERSION = '0.1.0'
+
+
+  # Generic Octothorpe error class
+  class OctoError < StandardError; end
+
+  # Raised when Octothorpe needs a hash but didn't get one
+  class BadHash < OctoError; end
+
+  # Raised when caller tries to modify a frozen Octothorpe
+  class Frozen < OctoError; end
+
+
+  ## 
+  # Inner class for storage. This is to minimise namespace collision with key
+  # names.  Not exposed to Octothorpe's caller.
+  #
+  class Storage
+    attr_reader :store
+
+    def initialize(hash)
+      @store = hash
+    end
+
+    def method_missing(method, *attrs)
+      super if (block_given? || !attrs.empty?)
+      @store[method.to_sym]
+    end
+
+  end
+  ##
+
+
+  ##
+  # :call-seq:
+  #   ot = Octothrpe.new(hash)
+  #
+  # Initialise an Octothorpe object by passing it a hash.
+  #
+  # You can create an empty OT by calling Octothorpe.new, but there's probably
+  # little utility in that, given that it is read-only.
+  #
+  # If you pass anything other than nil or something OT can treat as a Hash,
+  # you will cause an Octothorpe::BadHash exception.
+  #
+  def initialize(hash=nil)
+    @store = Storage.new( symbol_hash(hash || {}) )
+    @inner_hash = @store.store
+  end
+
+
+  ##
+  # :call-seq:
+  #   ot.>>.keyname
+  #
+  # You can use >> to access member objects in somewhat the same way as an
+  # OpenStruct.
+  #
+  #   ot = Octotghorpe.new(one: 1, "two" => 2)
+  #   ot.>>.one  # -> 1
+  #
+  # This will not work for members that have keys with spaces in, or keys which
+  # have the same name as methods on Object. Use _get_ for those.
+  #
+  def >>; @store; end
+
+
+  ##
+  # :call-seq:
+  #   ot.get(key)
+  #   ot.send(key)
+  #
+  # You can use get to access member object values instead of the >> syntax.
+  #
+  # Unlike >>, this works for keys with spaces, or keys that have the same name
+  # as methods on Object.
+  #
+  def get(key); @store.store[key.to_sym]; end
+
+  alias send get
+
+
+  ##
+  # Returns a hash of the object.
+  #
+  def to_h; @store.store; end
+
+
+  ##
+  # :call-seq:
+  #   ot.guard( class, key [, key, ...] )
+  #
+  # Guarantees the initial state of a memnber. Each key that is not already
+  # present will be set to <class>.new. Has no effect if key is already
+  # present.
+  #
+  # Class must be some class Thing that can respond to a vanilla Thing.new.
+  #
+  # Note that this is the only time that you can modify an Octothorpe object
+  # once it is created. If you call _freeze_ on an it, it will become genuinely
+  # read-only, and any call to guard from then on will raise Octothorpe::Frozen.
+  #
+  def guard(klass, *keys)
+    raise Frozen if self.frozen?
+    keys.map(&:to_sym).each{|k| @store.store[k] ||= klass.new }
+    self
+  end
+
+
+  ##
+  # :call-seq:
+  #   ot.merge(other)                              -> new_ot
+  #   ot.merge(other){|key, oldval, newval| block} -> new_ot
+  #
+  # Exactly has _Hash.merge_, but returns a new Octothorpe object.
+  #
+  # You may pass a hash or an octothorpe. Raises Octothorpe::BadHash
+  # if it is anything else.
+  #
+  def merge(other)
+    otherHash = symbol_hash(other)
+
+    merged = 
+      if block_given?
+        @store.store.merge(otherHash) {|key,old,new| yield key, old, new }
+      else
+        @store.store.merge(otherHash)
+      end
+
+    return Octothorpe.new(merged)
+  end
+
+
+  private
+
+
+  ##
+  # Try to return thing as a hash with symbols for keys
+  #
+  def symbol_hash(thing)
+    if thing.kind_of?(Octothorpe)
+      thing.to_h
+    else
+      thing.each_with_object({}) {|(k,v),m| m[k.to_sym] = v }
+    end
+  rescue
+    raise BadHash
+  end
+
+
+end
+

data/octothorpe.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'octothorpe'
+
+Gem::Specification.new do |spec|
+  spec.name          = "octothorpe"
+  spec.version       = Octothorpe::VERSION
+  spec.authors       = ["Andy Jones"]
+  spec.email         = ["andy@twosticksconsulting.co.uk"]
+  spec.summary       = %q{Like a Hash. Better for message passing between classes, I hope.}
+
+  spec.description   = <<-DESCRIPTION.gsub(/^\s+/, '')
+    A very simple hash-like class that borrows a little from OpenStruct, etc.
+
+    * Treats string and symbol keys as equal
+    * Access member objects with ot.>>.keyname
+    * Guard conditions allow you to control what returns if key is not present
+    * Pretty much read-only, for better or worse
+
+    Meant to facilitate message-passing between classes.
+  DESCRIPTION
+
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `hg status -macn0`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-doc"
+end

data/spec/doc_no_pending.rb

@@ -0,0 +1,5 @@
+class DocNoPending < RSpec::Core::Formatters::DocumentationFormatter
+  RSpec::Core::Formatters.register self, :example_pending
+
+  def example_pending(notification); end
+end

data/spec/octothorpe_spec.rb

@@ -0,0 +1,205 @@
+require 'octothorpe'
+
+describe Octothorpe do
+
+
+  before do
+    @hash  = {one: 'a', 'two' => 2, dup: 3, "weird key" => 4}
+    @hash2 = @hash.each_with_object({}) {|(k,v),m| m[k.to_sym] = v }
+    @ot    = Octothorpe.new(@hash)
+  end
+
+
+  describe "#new" do
+
+    it "takes a hash" do
+      expect{ Octothorpe.new(one: 2, three: 4) }.not_to raise_exception
+    end
+
+    it "accepts no arguments" do
+      expect{ Octothorpe.new }.not_to raise_exception
+    end
+
+    it "raises Octothorpe::BadHash if passed non-hash, non-nil" do
+      expect{ Octothorpe.new("hello") }.to raise_exception Octothorpe::BadHash
+      expect{ Octothorpe.new(:boo)    }.to raise_exception Octothorpe::BadHash
+      expect{ Octothorpe.new(14)      }.to raise_exception Octothorpe::BadHash
+    end
+
+  end
+
+
+  describe "#>>" do
+
+    it "returns the value with the given key" do
+      expect(@ot.>>.one).to eq @hash2[:one]
+      expect(@ot.>>.two).to eq @hash2[:two]
+    end
+
+    it "returns nil when given a non-key value" do
+      expect(@ot.>>.three).to be_nil
+    end
+
+    it "throws an exception if passed a parameter or block" do
+      expect{ @ot.>>.three(1)          }.to raise_exception
+      expect{ @ot.>>.three{|x| puts x} }.to raise_exception
+    end
+
+  end
+
+
+  describe "#get" do
+
+    it "returns the value with the given key" do
+      expect( @ot.get(:one) ).to eq @hash2[:one]
+      expect( @ot.get(:two) ).to eq @hash2[:two]
+    end
+
+    it "returns nil when given a non-key value" do
+      expect( @ot.get(:three) ).to be_nil
+    end
+
+    it "will return odd keys" do
+      expect( @ot.get(:dup)        ).to eq @hash2[:dup]
+      expect( @ot.get('weird key') ).to eq @hash2[:'weird key']
+    end
+
+  end
+
+
+  describe "#to_h" do
+
+    it "dumps the OT as a hash" do
+      expect( @ot.to_h ).to eq @hash2
+    end
+
+  end
+
+
+  describe "#guard" do
+
+    it "sets the given fields with a default value for the class" do
+      @ot.guard(Array, :alpha)
+      @ot.guard(Hash,  :beta)
+
+      expect( @ot.>>.alpha ).to eq([])
+      expect( @ot.>>.beta  ).to eq({})
+    end
+
+    it "returns self" do
+      expect( @ot.guard(Array, :foo) ).to eq @ot
+    end
+
+    it "only sets the field if it does not already exist" do
+      @ot.guard(Array, :one)
+      expect( @ot.>>.one ).to eq @hash2[:one]
+    end
+
+    it "accepts a list of keys" do
+      @ot.guard(Array, :fred, :daphne, "velma")
+      otHash = @ot.to_h
+      expect( otHash[:fred]   ).to eq([])
+      expect( otHash[:daphne] ).to eq([])
+      expect( otHash[:velma]  ).to eq([])
+    end
+
+    it "raises Octothorpe::Frozen if the OT is frozen" do
+      @ot.freeze
+      expect{ @ot.guard(Hash, :foo) }.to raise_exception Octothorpe::Frozen
+    end
+
+  end
+
+
+  describe "#merge" do
+    before do
+      @other = {fred: 1, "velma" => 2}
+    end
+
+    it "accepts a hash" do
+      expect{ @ot.merge(@other) }.not_to raise_exception
+    end
+
+    it "accepts another OT" do
+      ot2 = Octothorpe.new(@other)
+      expect{ @ot.merge(ot2) }.not_to raise_exception
+    end
+
+    it "raises Octothorpe::BadHash if the parameter cannot be turned into a hash" do
+      expect{ @ot.merge(12)  }.to raise_exception Octothorpe::BadHash
+      expect{ @ot.merge(nil) }.to raise_exception Octothorpe::BadHash
+    end
+
+    it "returns a new OT that combines the self OT with another" do
+      ot2    = @ot.merge(@other)
+      other2 = @other.each_with_object({}) {|(k,v),m| m[k.to_sym] = v }
+
+      expect( ot2      ).to be_a( Octothorpe )
+      expect( ot2.to_h ).to eq( @hash2.merge(other2) )
+    end
+
+    it "honours the Hash.merge block format" do
+      h1  = {one: 1, two: 2}
+      h2  = {one: 3, two: 4}
+
+      ot  = Octothorpe.new(h1)
+      ans = ot.merge(h2){|k,o,n| o.to_s + '.' + n.to_s }
+
+      expect( ans.to_h ).to eq( {one: '1.3', two: '2.4'} )
+    end
+
+  end
+
+
+  describe "(miscelaneous other stuff)" do
+    # I "imagine" that the actual class uses Forwardable, but the test code
+    # shouldn't know or care about that.  In any case, just testing with
+    # responds_to always feels like cheating.
+
+    it "behaves like a Hash for a bunch of query methods" do
+      expect( @ot.empty? ).not_to eq true
+      expect( Octothorpe.new().empty? ).to eq true
+
+      expect( @ot.has_key?(:two) ).to eq true
+      expect( @ot.has_key?(:four) ).not_to eq true
+
+      expect( @ot.has_value?(3) ).to eq true
+      expect( @ot.has_value?(14) ).not_to eq true
+
+      expect( @ot.include?(:two) ).to eq true
+      expect( @ot.include?(:foo) ).not_to eq true
+    end
+
+    it "behaves like a hash for a bunch of methods that return an array" do
+      expect( @ot.keys   ).to eq(@hash2.keys)
+      expect( @ot.values ).to eq(@hash2.values)
+
+      expect( @ot.map{|k,v| k} ).to eq( @hash2.map{|k,v| k} )
+
+      ans = @hash2.select{|k,_| k == :two }
+      expect( @ot.select{|k,v| k == :two } ).to eq( {two: 2} )
+
+      ans = @hash2.reject{|k,_| k == :two }
+      expect(  @ot.reject{|k,_| k == :two } ).to eq( ans )
+    end
+
+    it "behaves like a hash for a bunch of iterators" do
+
+      expect( @ot.inject(0){|m,(k,v)| m += v.to_i } ).to eq 9
+
+      expect{ @ot.each{|k,v| } }.not_to raise_exception
+      ans = []; @ot.each{|k,_| ans << k}
+      expect( ans ).to eq( @hash2.keys )
+
+      ans = []; @ot.each_key{|k| ans << k}
+      expect(ans).to eq( @hash2.keys )
+
+      ans = []; @ot.each_value{|v| ans << v} 
+      expect(ans).to eq( @hash2.values )
+    end
+
+  end
+
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,96 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: octothorpe
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Andy Jones
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-doc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'A very simple hash-like class that borrows a little from OpenStruct,
+  etc.
+
+  * Treats string and symbol keys as equal
+
+  * Access member objects with ot.>>.keyname
+
+  * Guard conditions allow you to control what returns if key is not present
+
+  * Pretty much read-only, for better or worse
+
+  Meant to facilitate message-passing between classes.
+
+'
+email:
+- andy@twosticksconsulting.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .hgignore
+- .rspec
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/octothorpe.rb
+- octothorpe.gemspec
+- spec/doc_no_pending.rb
+- spec/octothorpe_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: Like a Hash. Better for message passing between classes, I hope.
+test_files:
+- spec/doc_no_pending.rb
+- spec/octothorpe_spec.rb
+- spec/spec_helper.rb
+has_rdoc: