dyna_struct 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14bad87fe3602d8b8b591ed263f4a3c690e50627
+  data.tar.gz: 53fa67ed916cb526cde82872c72f4a4a11c9358d
+SHA512:
+  metadata.gz: cb99c5957906fad30aa128112a637b10d84dd0d7f0b345f93ca8bfb4735e6fa0251015f67bb6a307e158c154236ac63436a9914df8ed7055c86e6c7ede917acf
+  data.tar.gz: 105582c4c8d876a6fbe824e3252ff7f4ab796f32778d506d68c1afb1f9dde0e79965e838b7bba5250c203108453c2fa2208c91527c39e7757cae0acd061bc31d

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.DS_Store
+*.swp

data/.rspec

@@ -0,0 +1 @@
+--color --format documentation

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dyna_struct.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 JC Wilcox
+
+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,85 @@
+# DynaStruct
+
+DynaStruct offers a number of classes which provide different ways to dynamically assign and interact with instance variables.
+This is accomplished through Ruby's metaprogramming, which allows the dynamic manipulation of data and methods for a specific object.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dyna_struct'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dyna_struct
+
+## Usage
+
+The DynaStruct module provides four classes, offering different degrees of complexity:
+
+* `DynaStruct::Base`
+* `DynaStruct::Reader`
+* `DynaStruct::Accessor`
+* `DynaStruct::Full`
+
+`DynaStruct::Base` contains only an initialize method, which takes a Hash and dynamically defines instance variables based on the values provided. So,
+
+    DynaStruct::Base.new(foo: 'bar')
+
+will yield a new object with instance variable `@foo = 'bar'`.
+
+`DynaStruct::Reader` offers this same functionality, with the addition of reader methods for instance variables.
+
+    x = DynaStruct::Reader.new(foo: 'bar)
+    x.foo   #=> 'bar'
+
+Similarly, `DynaStruct::Accessor` adds both getter and setter methods:
+
+    y = DynaStruct::Accessor.new(foo: 'bar')
+    x.foo = 7
+    x.foo   #=> 7
+
+`DynaStruct::Full` offers all of the above features, as well as most of the features offered by Ruby's OpenStruct class.
+
+    z = DynaStruct::Full.new(foo: 'bar')
+    z[:foo]   #=> 'bar'
+    z['abc'] = 'def'
+    z.abc   #=> 'def'
+    z.to_h   #=> { foo: 'bar', abc: 'def' }
+
+DynaStruct also offers a `DynaStruct::Modifiable` module, which adds three classes:
+
+* `DynaStruct::Modifiable::Base`
+* `DynaStruct::Modifiable::Reader`
+* `DynaStruct::Modifiable::Accessor`
+
+These classes correspond to the above classes, but add 3 methods: `.<<`, `.remove`, and `.empty?`,
+which allow the user to make some modifications to the object after instantiation.
+
+    x = DynaStruct::Modifiable::Reader.new
+    x.empty?   #=> true
+    x << { abc: 'def' }
+    x.empty?   #=> false
+    x.abc   #=> 'def'
+    x.remove(:abc)   #=> 'def'
+    x.empty?   #=> true
+
+* * *
+
+The biggest advantage these classes have over Ruby's OpenStruct is inheritance.
+
+    class Foo < DynaStruct::Reader; end
+
+defines a class that can be initialized with an arbitrary Hash and automagically possess instance variables and reader methods corresponding to that Hash.
+
+## Contributing
+
+1. Fork it ( http://github.com/xDAGRONx/dyna_struct/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/dyna_struct.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dyna_struct/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dyna_struct"
+  spec.version       = DynaStruct::VERSION
+  spec.authors       = ["JC Wilcox"]
+  spec.email         = ["84jwilcox@gmail.com"]
+  spec.summary       = %q{An alternative to Ruby's Struct, DynaStruct allows dynamic assignment of instance variables.}
+  spec.description   = %q{DynaStruct offers a number of classes which provide different ways to dynamically assign and interact with instance variables. This is accomplished through Ruby's metaprogramming, which allows the dynamic manipulation of data and methods for a specific object.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.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.5"
+  spec.add_development_dependency "rake"
+end

data/lib/dyna_struct.rb

@@ -0,0 +1,13 @@
+require "dyna_struct/version"
+require "dyna_struct/base"
+require "dyna_struct/reader"
+require "dyna_struct/accessor"
+require "dyna_struct/modifiable"
+require "dyna_struct/modifiable/base"
+require "dyna_struct/modifiable/reader"
+require "dyna_struct/modifiable/accessor"
+require "dyna_struct/full"
+
+module DynaStruct
+  # Your code goes here...
+end

data/lib/dyna_struct/accessor.rb

@@ -0,0 +1,12 @@
+module DynaStruct
+  class Accessor < Base
+    private
+      def add_attributes(args)
+        args.each do |k, v|
+          instance_variable_set("@#{k}", v)
+          define_singleton_method("#{k}") { instance_variable_get("@#{k}") }
+          define_singleton_method("#{k}=") { |value| instance_variable_set("@#{k}", value) }
+        end
+      end
+  end
+end

data/lib/dyna_struct/base.rb

@@ -0,0 +1,14 @@
+module DynaStruct
+  class Base
+    def initialize(args=nil)
+      add_attributes(args) if args.kind_of?(Hash)
+    end
+
+    private
+      def add_attributes(args)
+        args.each do |k, v|
+          instance_variable_set("@#{k}", v)
+        end
+      end
+  end
+end

data/lib/dyna_struct/full.rb

@@ -0,0 +1,67 @@
+module DynaStruct
+  class Full
+    def initialize(args=nil)
+      args.each_pair do |k, v|
+        instance_variable_set("@#{k}", v)
+        add_attribute(k)
+      end if args.kind_of?(Hash)
+    end
+
+    def [](name)
+      instance_variable_get("@#{name}")
+    end
+
+    def []=(name, value)
+      instance_variable_set("@#{name}", value)
+      add_attribute(name)
+      value
+    end
+
+    def to_h
+      instance_variables.inject({}) do |result, var|
+        result.merge var.to_s[1..-1].to_sym => instance_variable_get(var)
+      end
+    end
+    alias_method :to_hash, :to_h
+
+    def delete_field(name)
+      if respond_to?(name)
+        remove_singleton_method(name, "#{name}=")
+        remove_instance_variable("@#{name}")
+      end
+    end
+
+    def method_missing(method_id, *args)
+      method_name = method_id.id2name
+      len = args.length
+      if method_name.chomp!(?=)
+        if len != 1
+          raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+        end
+        self[method_name] = args.first
+      elsif method_name.chomp!(??)
+        unless len.zero?
+          raise ArgumentError, "wrong number of arguments (#{len} for 0)", caller(1)
+        end
+        !!self[method_name]
+      elsif len == 0
+        self[method_name]
+      else
+        super
+      end
+    end
+
+    private
+      def add_attribute(name)
+        unless respond_to?(name)
+          define_singleton_method("#{name}") { instance_variable_get("@#{name}") }
+          define_singleton_method("#{name}=") { |value| instance_variable_set("@#{name}", value) }
+        end
+        name
+      end
+
+      def remove_singleton_method(*method_names)
+        singleton_class.send(:remove_method, *method_names)
+      end
+  end
+end

data/lib/dyna_struct/modifiable.rb

@@ -0,0 +1,30 @@
+module DynaStruct
+  module Modifiable
+    def <<(args)
+      add_attributes args if args.kind_of?(Hash)
+      self
+    end
+
+    def remove(*vars)
+      result = vars.map do |var|
+        remove_singleton_method(var.to_s) if singleton_method_defined?(var.to_s)
+        remove_singleton_method("#{var}=") if singleton_method_defined?("#{var}=")
+        remove_instance_variable("@#{var}") if instance_variable_defined?("@#{var}")
+      end
+      result.length == 1 ? result.first : result
+    end
+
+    def empty?
+      instance_variables.empty?
+    end
+
+    private
+      def remove_singleton_method(method_name)
+        singleton_class.send(:remove_method, method_name)
+      end
+
+      def singleton_method_defined?(method_name)
+        singleton_class.send(:method_defined?, method_name)
+      end
+  end
+end

data/lib/dyna_struct/modifiable/accessor.rb

@@ -0,0 +1,7 @@
+module DynaStruct
+  module Modifiable
+    class Accessor < DynaStruct::Accessor
+      include Modifiable
+    end
+  end
+end

data/lib/dyna_struct/modifiable/base.rb

@@ -0,0 +1,7 @@
+module DynaStruct
+  module Modifiable
+    class Base < DynaStruct::Base
+      include Modifiable
+    end
+  end
+end

data/lib/dyna_struct/modifiable/reader.rb

@@ -0,0 +1,7 @@
+module DynaStruct
+  module Modifiable
+    class Reader < DynaStruct::Reader
+      include Modifiable
+    end
+  end
+end

data/lib/dyna_struct/reader.rb

@@ -0,0 +1,11 @@
+module DynaStruct
+  class Reader < Base
+    private
+      def add_attributes(args)
+        args.each do |k, v|
+          instance_variable_set("@#{k}", v)
+          define_singleton_method("#{k}") { instance_variable_get("@#{k}") }
+        end
+      end
+  end
+end

data/lib/dyna_struct/version.rb

@@ -0,0 +1,3 @@
+module DynaStruct
+  VERSION = "0.0.2"
+end

data/spec/lib/dyna_struct/accessor_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe DynaStruct::Accessor do
+  describe '.new' do
+    include_examples 'DynaStruct::Accessor.new'
+  end
+end

data/spec/lib/dyna_struct/base_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe DynaStruct::Base do
+  describe '.new' do
+    include_examples 'DynaStruct.new'
+  end
+end

data/spec/lib/dyna_struct/full_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe DynaStruct::Full do
+  describe '.new' do
+    subject { described_class.new(info) }
+
+    context 'given a hash' do
+      context 'with valid info' do
+        let(:info) { { a: ?a, b: ?b, ab: 12, a18: nil } }
+
+        it 'should assign instance variables corresponding to the Hash' do
+          info.each do |key, value|
+            subject.instance_variable_get("@#{key}")
+              .should eq value
+          end
+        end
+
+        it 'should create getter and setter methods' do
+          info.each do |key, value|
+            should respond_to(key)
+            subject.send(key).should eq value
+            should respond_to("#{key}=")
+          end
+        end
+      end
+
+      context 'with invalid keys' do
+        let(:info) { { 9 => 2, ?@ => 4 } }
+
+        it 'should raise an exception' do
+          expect { subject }.to raise_exception(NameError)
+        end
+      end
+    end
+
+    context 'given anything besides a hash' do
+      it 'should return an empty DynaStruct' do
+        [:hi, 0, -1, 5, '', ?a, 'abc', nil, false, true, 1.05, [1,?b,3.0]].each do |arg|
+          test = described_class.new(arg)
+          test.should be_a(described_class)
+          test.instance_variables.should be_empty
+        end
+      end
+    end
+  end
+
+  describe '.[]' do
+    let(:info) { { a: ?a, b: ?b } }
+
+    context 'given a valid attribute' do
+      subject { described_class.new(info)[:a] }
+
+      it 'should return the associated value' do
+        should eq ?a
+      end
+    end
+
+    context 'given an invalid attribute' do
+      subject { described_class.new(info)[:c] }
+
+      it 'should return nil' do
+        should be_nil
+      end
+    end
+
+    context 'given an impossible attribute' do
+      subject { described_class.new(info)['@99'] }
+
+      it { expect { subject }.to raise_exception(NameError) }
+    end
+  end
+
+  describe '.[]=' do
+    subject { described_class.new(b: 3) }
+
+    it 'should return the value' do
+      subject.[]=(:c, 12).should eq 12
+    end
+
+    context 'setting a new attribute' do
+      before { subject[:a] = 2 }
+
+      it 'should set the instance variable' do
+        subject.instance_variable_get(:@a).should eq 2
+      end
+
+      it 'should create getter and setter methods' do
+        should respond_to(:a)
+        subject.a.should eq 2
+        should respond_to(:a=)
+      end
+    end
+
+    context 'attribute already exists' do
+      before { subject[:b] = 5 }
+
+      it 'should override the value' do
+        subject.instance_variable_get(:@b).should eq 5
+      end
+
+      it 'should not break getters or setters' do
+        should respond_to(:b)
+        subject.b.should eq 5
+        should respond_to(:b=)
+      end
+    end
+
+    context 'setting an impossible attribute' do
+      subject { described_class.new['@99'] = 12 }
+
+      it { expect { subject }.to raise_exception(NameError) }
+    end
+  end
+
+  describe '.to_h' do
+    subject { described_class.new(info) }
+    let(:info) { { a: ?a, b: ?b, ab: 12, a18: nil } }
+
+    it 'should return the hash of instance variables and values' do
+      subject.to_h.should eq info
+    end
+
+    it 'should use symbols as keys' do
+      subject.to_h.keys.each do |key|
+        key.should be_a(Symbol)
+      end
+    end
+
+    it 'should return the variable names without the @' do
+      subject.to_h.keys.each do |key|
+        key.to_s[0].should_not eq(?@)
+      end
+    end
+  end
+
+  describe '.delete_field' do
+    subject { described_class.new(info) }
+    let(:info) { { a: ?a, b: ?b, ab: 12, a18: nil } }
+
+    context 'field exists' do
+      it 'should remove the getter and setter methods' do
+        subject.delete_field(:a)
+        should_not respond_to :a
+        should_not respond_to :a=
+      end
+
+      it 'should remove the instance variable' do
+        subject.delete_field(:a)
+        subject.instance_variable_get(:@a).should be_nil
+      end
+
+      it 'should return the value of the deleted variable' do
+        subject.delete_field(:a).should eq info[:a]
+      end
+    end
+
+    context 'field does not exist' do
+      it 'should not raise error' do
+        expect { subject.delete_field(:charlie) }.not_to raise_exception
+      end
+
+      it 'should return nil' do
+        subject.delete_field(:charlie).should be_nil
+      end
+    end
+  end
+
+  describe '.method_missing' do
+    subject { described_class.new(info) }
+    let(:info) { { a: ?a, b: ?b, ab: 12, a18: nil } }
+
+    context 'given method ending in =' do
+      context 'given more than 1 argument' do
+        it 'should raise an argument error' do
+          expect { subject.send('beta=', 19, 3) }.to raise_exception(ArgumentError)
+        end
+      end
+
+      context 'given no arguments' do
+        it 'should raise an argument error' do
+          expect { subject.send('beta=') }.to raise_exception(ArgumentError)
+        end
+      end
+
+      context 'given a single argument' do
+        it 'should set the instance variable' do
+          subject.beta = 19
+          subject.instance_variable_get(:@beta).should eq 19
+        end
+
+        it 'should create getter and setter methods' do
+          subject.beta = 19
+          should respond_to(:beta)
+          subject.beta.should eq 19
+          should respond_to(:beta=)
+        end
+
+        it 'should return the value' do
+          subject.send('beta=', 19).should eq 19
+        end
+      end
+    end
+
+    context 'given a method ending in ?' do
+      context 'given an argument' do
+        it { expect { subject.beta?(12) }.to raise_exception(ArgumentError) }
+      end
+
+      context 'not given an argument' do
+        it 'should return the boolean value of the attribute' do
+          subject.beta?.should be_false
+          subject.a?.should be_true
+        end
+      end
+    end
+
+    context 'given a method not ending in = or ?' do
+      context 'given no arguments' do
+        it 'should return nil' do
+          subject.hello.should be_nil
+        end
+      end
+
+      context 'given an argument' do
+        it { expect { subject.alpha(2) }.to raise_exception(NoMethodError) }
+      end
+    end
+  end
+end

data/spec/lib/dyna_struct/modifiable/accessor_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe DynaStruct::Modifiable::Accessor do
+  describe '.new' do
+    include_examples 'DynaStruct::Accessor.new'
+  end
+  include_examples 'Modifiable'
+end

data/spec/lib/dyna_struct/modifiable/base_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe DynaStruct::Modifiable::Base do
+  describe '.new' do
+    include_examples 'DynaStruct.new'
+  end
+  include_examples 'Modifiable'
+end

data/spec/lib/dyna_struct/modifiable/reader_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe DynaStruct::Modifiable::Reader do
+  describe '.new' do
+    include_examples 'DynaStruct::Reader.new'
+  end
+  include_examples 'Modifiable'
+end

data/spec/lib/dyna_struct/reader_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe DynaStruct::Reader do
+  describe '.new' do
+    include_examples 'DynaStruct::Reader.new'
+  end
+end

data/spec/modifiable_spec.rb

@@ -0,0 +1,62 @@
+shared_examples 'Modifiable' do
+  describe '.<<' do
+    subject { new_struct << info }
+    let(:info) { { hi: 'hello' } }
+    let(:new_struct) { described_class.new }
+    
+    it 'should return self' do
+      should be_a(described_class)
+      should be(new_struct)
+    end
+
+    def adding_method(args)
+      described_class.new << args
+    end
+
+    include_examples 'add_attributes'
+  end
+
+  describe '.empty?' do
+    subject { described_class.new }
+
+    it { should respond_to(:empty?) }
+
+    context 'no attributes assigned' do
+      it { should be_empty }
+    end
+
+    context 'attributes assigned' do
+      before(:each) { subject << { hi: 'hello' } }
+
+      it { should_not be_empty }
+    end
+  end
+
+  describe '.remove' do
+    subject { described_class.new info }
+    let(:info) { { a: ?a, b: ?b } }
+
+    context 'passed valid attributes' do
+      it 'should return the array of deleted values' do
+        subject.remove(*info.keys).should eq info.values
+      end
+
+      it 'should return just the value if one attribute given' do
+        subject.remove(info.keys.first).should eq info.values.first
+      end
+    end
+
+    context 'passed invalid attributes' do
+      it 'should return nil for those attributes' do
+        subject.remove(:a, 'boop').should eq [?a, nil]
+        subject.remove('boop').should be_nil
+      end
+    end
+
+    context 'passed nothing' do
+      it 'should return an empty array' do
+        subject.remove.should eq []
+      end
+    end
+  end
+end

data/spec/shared_specs.rb

@@ -0,0 +1,72 @@
+shared_examples 'DynaStruct.new' do
+  def adding_method(args)
+    described_class.new args
+  end
+
+  include_examples 'add_attributes'
+end
+
+shared_examples 'DynaStruct::Reader.new' do
+  include_examples 'DynaStruct.new'
+
+  subject { described_class.new info }
+  let(:info) { { a: ?a, b: ?b, ab: 12, a18: nil } }
+
+  it 'should create getter methods' do
+    info.each do |key, value|
+      should respond_to(key)
+      subject.send(key).should eq value
+    end
+  end
+end
+
+shared_examples 'DynaStruct::Accessor.new' do
+  include_examples 'DynaStruct::Reader.new'
+
+  subject { described_class.new info}
+  let(:info) { { a: ?a, b: ?b, ab: 12, a18: nil } }
+
+  it 'should create setter methods' do
+    info.each do |key, value|
+      should respond_to("#{key}=")
+      expect { subject.send("#{key}=", -2) }
+        .not_to raise_exception
+      subject.send(key).should eq -2
+    end
+  end
+end
+
+shared_examples 'add_attributes' do
+  context 'given a Hash' do
+    subject { adding_method(info) }
+
+    context 'with valid info' do
+      let(:info) { { a: ?a, b: ?b, ab: 12, a18: nil } }
+
+      it 'should assign instance variables corresponding to the Hash' do
+        info.each do |key, value|
+          subject.instance_variable_get("@#{key}")
+            .should eq value
+        end
+      end
+    end
+
+    context 'with invalid keys' do
+      let(:info) { { 9 => 2, ?@ => 4 } }
+
+      it 'should raise an exception' do
+        expect { subject }.to raise_exception(NameError)
+      end
+    end
+  end
+
+  context 'given anything that is not a Hash' do
+    it 'should not change the DynaStruct' do
+      [:hi, 0, -1, 5, '', ?a, 'abc', nil, false, true, 1.05, [1,?b,3.0]].each do |arg|
+        subject = adding_method(arg)
+        subject.should be_a(described_class)
+        subject.instance_variables.should eq []
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'dyna_struct'
+require 'shared_specs'
+require 'modifiable_spec'

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: dyna_struct
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- JC Wilcox
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: DynaStruct offers a number of classes which provide different ways to
+  dynamically assign and interact with instance variables. This is accomplished through
+  Ruby's metaprogramming, which allows the dynamic manipulation of data and methods
+  for a specific object.
+email:
+- 84jwilcox@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dyna_struct.gemspec
+- lib/dyna_struct.rb
+- lib/dyna_struct/accessor.rb
+- lib/dyna_struct/base.rb
+- lib/dyna_struct/full.rb
+- lib/dyna_struct/modifiable.rb
+- lib/dyna_struct/modifiable/accessor.rb
+- lib/dyna_struct/modifiable/base.rb
+- lib/dyna_struct/modifiable/reader.rb
+- lib/dyna_struct/reader.rb
+- lib/dyna_struct/version.rb
+- spec/lib/dyna_struct/accessor_spec.rb
+- spec/lib/dyna_struct/base_spec.rb
+- spec/lib/dyna_struct/full_spec.rb
+- spec/lib/dyna_struct/modifiable/accessor_spec.rb
+- spec/lib/dyna_struct/modifiable/base_spec.rb
+- spec/lib/dyna_struct/modifiable/reader_spec.rb
+- spec/lib/dyna_struct/reader_spec.rb
+- spec/modifiable_spec.rb
+- spec/shared_specs.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: An alternative to Ruby's Struct, DynaStruct allows dynamic assignment of
+  instance variables.
+test_files:
+- spec/lib/dyna_struct/accessor_spec.rb
+- spec/lib/dyna_struct/base_spec.rb
+- spec/lib/dyna_struct/full_spec.rb
+- spec/lib/dyna_struct/modifiable/accessor_spec.rb
+- spec/lib/dyna_struct/modifiable/base_spec.rb
+- spec/lib/dyna_struct/modifiable/reader_spec.rb
+- spec/lib/dyna_struct/reader_spec.rb
+- spec/modifiable_spec.rb
+- spec/shared_specs.rb
+- spec/spec_helper.rb