hash_initialized_struct 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28eb0a537f9077e0834c71e8bc6ca52d2038c67e
+  data.tar.gz: f55ba4273ae166f51743a855fda5f9dcec7fece1
+SHA512:
+  metadata.gz: 3d4498296eb6deaa2e57b3bf64629657a24d9db6d108549804012e6e4128f68922cf0ff7b76e72d3124c847d9c37a7fcd725489e4dd9dd22dfcdcf1f9bc5f3f9
+  data.tar.gz: 1d98179af8ca82f5d29c54929f66c4f9110a2079e488f415854aaec6d70720325dfad205a08cfb7e838e35486141cc7a66ad1d9a7fa184bde79a555a7f1f2420

data/.gitignore

@@ -0,0 +1,7 @@
+/.bundle
+/Gemfile.lock
+/coverage
+/pkg
+/spec/reports
+/tmp
+*.bundle

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2015 Rob Howard
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

data/README.md

@@ -0,0 +1,70 @@
+# Hash-Initialized Struct
+
+Halfway between Struct and OpenStruct. (Or: Struct, except it takes a Hash on object initialization.)
+
+Ignore if you already use [Virtus](https://github.com/solnic/virtus) or [Hashie::Dash](https://github.com/intridea/hashie).
+
+
+## Usage
+
+```ruby
+class Point < HashInitializedStruct.new(:x, :y); end
+# Or: Point = HashInitializedStruct.new(:x, :y)
+
+point = Point.new(x: 1, y: 2)
+point.x # => 1
+
+unknowns = Point.new(x: 1, y: 2, z: 3)
+# => raises ArgumentError, "Unrecognised keys: :z"
+
+missing = Point.new(x: 1)
+# => raises ArgumentError, "Missing keys: :y"
+```
+
+### Fancy Usage
+
+```ruby
+class Point < HashInitializedStruct.new(:x, :y)
+  def initialize(attrs)
+    super
+    [x, y].each do |attr|
+      raise ArgumentError, "#{attr} must be a number" unless attr.kind_of?(Numeric)
+    end
+  end
+end
+
+good = Point.new(x: 1, y: 2)
+good.x # => 1
+
+bad = Point.new(x: "1", y: nil)
+# => raises ArgumentError, "x must ..."
+```
+
+
+### Fancier Usage
+
+Stop. Go use [Virtus](https://github.com/solnic/virtus).
+
+
+## Installation
+
+Add the following to your application's Gemfile:
+
+```ruby
+gem 'hash_initialized_struct'
+```
+
+And then run `bundle install`.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/damncabbage/hash_initialized_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 a new Pull Request
+
+## License
+
+See LICENSE.txt

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+task :default => :spec

data/hash_initialized_struct.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hash_initialized_struct/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hash_initialized_struct"
+  spec.version       = HashInitializedStruct::VERSION
+  spec.authors       = ["Rob Howard"]
+  spec.email         = ["rob@robhoward.id.au"]
+  spec.summary       = %Q{Struct, except it takes a Hash on object initialization.}
+  spec.description   = %Q{Struct, except it takes a Hash on object initialization.\nclass Point < HashInitializedStruct.new(:x, :y); end; Point.new(x: 1, y: 2)}
+  spec.homepage      = "https://github.com/damncabbage/hash_initialized_struct"
+  spec.license       = "Apache 2.0"
+
+  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.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+end

data/lib/hash_initialized_struct/version.rb

@@ -0,0 +1,3 @@
+class HashInitializedStruct
+  VERSION = "1.0.0"
+end

data/lib/hash_initialized_struct.rb

@@ -0,0 +1,51 @@
+require "hash_initialized_struct/version"
+
+# class Point < HashInitializedStruct(:x, :y); end
+# Or: Point = HashInitializedStruct(:x, :y)
+#
+# point  = Point.new(x: 1, y: 2)
+# point.x # => 1
+#
+# point2 = Point.new(x: 1, y: 2, nonsense: "foobar")
+# # => raises ArgumentError
+class HashInitializedStruct
+  class << self
+    alias :subclass_new :new
+  end
+
+  def self.new(*attrs)
+    symbol_attrs = attrs.map do |a|
+      case a
+      when Symbol
+        a
+      else
+        a.to_sym.tap do |sym|
+          raise TypeError, "Could not coerce #{a.inspect} to symbol" unless sym.kind_of?(Symbol)
+        end
+      end
+    end
+
+    Class.new self do
+      const_set :STRUCT_ATTRS, symbol_attrs
+      attr_accessor *symbol_attrs
+
+      def self.new(*args, &block)
+        self.subclass_new(*args, &block)
+      end
+
+      def initialize(attrs)
+        provided = attrs.keys
+        needed   = self.class::STRUCT_ATTRS
+        (provided - needed).tap do |unknown|
+          raise ArgumentError, "Unrecognised keys: #{unknown.map(&:inspect).join(', ')}" unless unknown.empty?
+        end
+        (needed - provided).tap do |missing|
+          raise ArgumentError, "Missing keys: #{missing.map(&:inspect).join(', ')}" unless missing.empty?
+        end
+        attrs.each do |attr,value|
+          instance_variable_set("@#{attr}", value)
+        end
+      end
+    end
+  end
+end

data/spec/hash_initialized_struct_spec.rb

@@ -0,0 +1,57 @@
+require 'hash_initialized_struct'
+
+describe "HashInitializedStruct" do
+  let(:klass) { HashInitializedStruct.new(:x, :y) }
+
+  it "creates a struct class that accepts initializing values via a Hash" do
+    point = klass.new(x: 1, y: 2)
+    expect(point.x).to eq 1
+    expect(point.y).to eq 2
+  end
+
+  it "creates a struct class that extends from HashInitializedStruct" do
+    expect(klass < HashInitializedStruct).to eq true
+  end
+
+  it "allows mutation of attributes" do
+    point = klass.new(x: 1, y: 2)
+    expect(point.x).to eq 1
+    point.x = 5
+    expect(point.x).to eq 5
+  end
+
+  it "disallows unrecognised keys" do
+    expect {
+      point = klass.new(x: 1, y: 2, z: 3)
+    }.to raise_error(ArgumentError, "Unrecognised keys: :z")
+    expect {
+      point = klass.new(x: 1, y: 2, self => "u wot")
+    }.to raise_error(ArgumentError, /Unrecognised keys: #<RSpec.*>/)
+  end
+
+  it "disallows creation with missing keys" do
+    expect {
+      point = klass.new(x: 1)
+    }.to raise_error(ArgumentError, "Missing keys: :y")
+  end
+
+  it "allows for overriding the constructor to add additional checks" do
+    # Could do this with an anonymous class and define_method, but we're trying to emulate
+    # how it might actually be used.
+    class My3DPoint < HashInitializedStruct.new(:x, :y, :z)
+      def initialize(attrs)
+        super
+        [x, y, z].each do |attr|
+          raise ArgumentError, "#{attr} must be a number" unless attr.kind_of?(Numeric)
+        end
+      end
+    end
+
+    good = My3DPoint.new(x: 1, y: 2, z: 9)
+    expect(good.x).to eq 1
+
+    expect {
+      My3DPoint.new(x: "1", y: nil, z: 9)
+    }.to raise_error(ArgumentError)
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: hash_initialized_struct
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Rob Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: |-
+  Struct, except it takes a Hash on object initialization.
+  class Point < HashInitializedStruct.new(:x, :y); end; Point.new(x: 1, y: 2)
+email:
+- rob@robhoward.id.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hash_initialized_struct.gemspec
+- lib/hash_initialized_struct.rb
+- lib/hash_initialized_struct/version.rb
+- spec/hash_initialized_struct_spec.rb
+homepage: https://github.com/damncabbage/hash_initialized_struct
+licenses:
+- Apache 2.0
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Struct, except it takes a Hash on object initialization.
+test_files:
+- spec/hash_initialized_struct_spec.rb