immutable-struct 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 89bdf872c24c20ae1e37d7401e9ba4a5c4c464bb
+  data.tar.gz: 521fa49dfeed67bba17e67df389ad5f228ad7b71
+SHA512:
+  metadata.gz: 2cec1d2b58020662208393fffbdad46b0082a1007edeab7478e69c67ec764b7c3a1231898c4314032d748bfe0767fb1787c7f2c4e1465e73e24c3b0a40e65e13
+  data.tar.gz: c7251a13f171e5418d84e4aab6d36c35a18ce9d35a4c19788b5dfea888a5360657728de99999fde97c7dff624e3f17d12505480510396c4a25a1f12b0cb4959b

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
+html
+.*.sw?

data/.ruby-gemset

@@ -0,0 +1 @@
+immutable-struct

data/.ruby-version

@@ -0,0 +1 @@
+2.1.0

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - rbx-2
+  - ruby-head

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dave Copeland
+
+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.rdoc

@@ -0,0 +1,47 @@
+= ImmutableStruct
+
+{<img src="https://travis-ci.org/stitchfix/immutable-struct.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/stitchfix/immutable-struct]
+
+Creates struct-like classes (that can build value objects) that do not have setters and also have better constructors than Ruby's built-in +Struct+.
+
+This is highly useful for creating presenters, non-database-related models, or other quick and dirty classes in your application.  Instead of using a +Hash+ or +OpenStruct+, you can create a bit more clarity around your types by using +ImmutableStruct+, which is almost as convienient.
+
+== Install
+
+Add to your +Gemfile+:
+
+    gem 'immutable-struct'
+
+Then install:
+
+    bundle install
+
+If not using bundler, just use RubyGems:
+
+    gem install immutable-struct
+
+
+== To use
+
+    Person = StitchFix::ImmutableStruct.new(:name, :age, :job, :active?) do
+      def minor?
+        age < 18
+      end
+    end
+
+    p = Person.new(name: "Dave",   # name will be 'Dave'
+                   age: 40,        # age will be 40
+                                   # job is omitted, so will be nil
+                   active: true)   # active and active? will be true
+    p.name    # => "Dave"
+    p.age     # => 40
+    p.active? # => true
+    p.minor?  # => false
+
+You can also treat the interior as a normal class definition.  
+
+== Links
+
+* rdoc[http://stitchfix.github.io/immutable-struct]
+* source[http://github.com/stitchfix/immutable-struct]
+* blog[http://technology.stitchfix.com/blog/2013/12/20/presenters-delegation-vs-structs/]

data/Rakefile

@@ -0,0 +1,42 @@
+require "bundler/gem_tasks"
+require "fileutils"
+
+include FileUtils
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+require "rdoc/task"
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.rdoc"
+  rdoc.rdoc_files.include("README.rdoc", "lib/*.rb")
+end
+
+def sh!(command)
+  sh command do |ok,res|
+    fail "Problem running '#{command}'" unless ok
+  end
+end
+
+task :publish_rdoc do
+  rm_rf "tmp"
+  mkdir_p "tmp"
+  chdir "tmp" do
+    sh! "git clone git@github.com:stitchfix/immutable-struct.git"
+    chdir "immutable-struct" do
+      sh! "git checkout gh-pages"
+      `rm -rf *`
+    end
+  end
+  Rake::Task["rdoc"].invoke
+  `cp -R html/* tmp/immutable-struct`
+  chdir "tmp/immutable-struct" do
+    sh! "git add -A ."
+    sh! "git commit -m 'updated rdoc'"
+    sh! "git push origin gh-pages"
+  end
+end
+
+task :default => :spec
+
+

data/immutable-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 'immutable-struct'
+
+Gem::Specification.new do |spec|
+  spec.name          = "immutable-struct"
+  spec.version       = ImmutableStruct::VERSION
+  spec.authors       = ["Stitch Fix Engineering"]
+  spec.email         = ["jobs@stitchfix.com"]
+  spec.description   = %q{Easily create value objects without the pain of Ruby's Struct (or its setters)}
+  spec.summary   = %q{Easily create value objects without the pain of Ruby's Struct (or its setters)}
+  spec.homepage      = "http://technology.stitchfix.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/immutable-struct.rb

@@ -0,0 +1,67 @@
+# Creates classes for value objects/read-only records.  Most useful
+# when creating model objects for concepts not stored in the database.
+#
+# This will create a class that has attr_readers for all given attributes, as
+# well as a hash-based constructor.  Further, the block given to with_attributes
+# will be evaluated as if it were inside a class definition, allowing you
+# to add methods, include or extend modules, or do whatever else you want.
+class ImmutableStruct
+  VERSION='2.0.0' #:nodoc:
+  # Create a new class with the given read-only attributes.
+  #
+  # attributes:: list of symbols or strings that can be used to create attributes.
+  #              Any attribute with a question mark in it (e.g. +:foo?+) will create
+  #              an attribute without a question mark that passes through the raw
+  #              value and an attribute *with* the question mark that coerces that
+  #              value to a boolean.  You would initialize it with the non-question-mark value
+  # block:: if present, evaluates in the context of the new class, so +def+, +def.self+, +include+
+  #         and +extend+ should all work as in a normal class definition.
+  #
+  # Example:
+  #
+  #     Person = ImmutableStruct.new(:name, :location, :minor?)
+  #
+  #     p = Person.new(name: 'Dave', location: Location.new("DC"), minor: false)
+  #     p.name     # => 'Dave'
+  #     p.location # => <Location: @where="DC">
+  #     p.minor    # => false
+  #     p.minor?   # => false
+  #
+  #     p = Person.new(name: 'Rudy', minor: "yup")
+  #     p.name     # => 'Rudy'
+  #     p.location # => nil
+  #     p.minor    # => "yup"
+  #     p.minor?   # => true
+  #
+  def self.new(*attributes,&block)
+    klass = Class.new do
+      attributes.each do |attribute|
+        if attribute.to_s =~ /(^.*)\?$/
+          raw_name = $1
+          attr_reader raw_name
+          define_method(attribute) do
+            !!instance_variable_get("@#{raw_name}")
+          end
+        else
+          attr_reader attribute
+        end
+      end
+
+      define_method(:initialize) do |*args|
+        attrs = args[0] || {}
+        attributes.each do |attribute|
+          ivar_name = attribute.to_s.gsub(/\?$/,'')
+          instance_variable_set("@#{ivar_name}",attrs[ivar_name.to_s] || attrs[ivar_name.to_sym])
+        end
+      end
+    end
+    klass.class_exec(&block) unless block.nil?
+    imethods = klass.instance_methods(include_super=false)
+    klass.class_exec(imethods) do |imethods|
+      define_method(:to_h) do
+        imethods.inject({}){ |hash, method| hash.merge(method.to_sym => self.send(method)) }
+      end
+    end
+    klass
+  end
+end

data/spec/immutable_struct_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper.rb'
+
+module TestModule
+  def hello; "hello"; end
+end
+
+describe ImmutableStruct do
+  describe "construction" do
+    context "with non-boolean attributes and no body" do
+      before do
+        @klass = ImmutableStruct.new(:foo, :bar, :baz)
+      end
+      subject { @klass.new }
+
+      it { should     respond_to(:foo) }
+      it { should     respond_to(:bar) }
+      it { should     respond_to(:baz) }
+      it { should_not respond_to(:foo=) }
+      it { should_not respond_to(:bar=) }
+      it { should_not respond_to(:baz=) }
+      it { should_not respond_to(:foo?) }
+      it { should_not respond_to(:bar?) }
+      it { should_not respond_to(:baz?) }
+
+      context "instances can be created with a hash" do
+        subject { @klass.new(foo: "FOO", bar: 42, baz: [:a,:b,:c]) }
+
+        it { subject.foo.should == "FOO" }
+        it { subject.bar.should == 42 }
+        it { subject.baz.should == [:a,:b,:c] }
+      end
+    end
+
+    context "intelligently handles boolean attributes" do
+      subject { ImmutableStruct.new(:foo?) }
+
+      context "with boolean values" do
+        it { subject.new(foo: false).foo?.should == false }
+        it { subject.new(foo: false).foo.should == false }
+        it { subject.new(foo: true).foo?.should == true }
+        it { subject.new(foo: true).foo.should == true }
+      end
+
+      context "with falsey, non-boolean values" do
+        it { subject.new.foo?.should == false }
+        it { subject.new.foo.should == nil }
+      end
+
+      context "with truthy, non-boolean values" do
+        it { subject.new(foo: "true").foo?.should == true }
+        it { subject.new(foo: "true").foo.should == "true" }
+      end
+
+    end
+
+    it "allows defining instance methods" do
+      klass = ImmutableStruct.new(:foo, :bar) do
+        def derived; self.foo + ":" + self.bar; end
+      end
+      instance = klass.new(foo: "hello", bar: "world")
+      instance.derived.should == "hello:world"
+    end
+
+    it "allows defining class methods" do
+      klass = ImmutableStruct.new(:foo, :bar) do
+        def self.from_array(array)
+          self.new(foo: array[0], bar: array[1])
+        end
+      end
+      instance = klass.from_array(["hello","world"])
+      instance.foo.should == "hello"
+      instance.bar.should == "world"
+    end
+
+    it "allows module inclusion" do
+      klass = ImmutableStruct.new(:foo) do
+        include TestModule
+      end
+      instance = klass.new
+
+      instance.should  respond_to(:hello)
+      klass.should_not respond_to(:hello)
+    end
+
+    it "allows module extension" do
+      klass = ImmutableStruct.new(:foo) do
+        extend TestModule
+      end
+      instance = klass.new
+
+      instance.should_not respond_to(:hello)
+      klass.should        respond_to(:hello)
+    end
+  end
+
+  describe "to_h" do
+    it "should include the output of params and block methods in the hash" do
+      klass = ImmutableStruct.new(:flappy) do
+        def lawsuit
+          'pending'
+        end
+      end
+      instance = klass.new(flappy: 'bird')
+      instance.to_h.should == {flappy: 'bird', lawsuit: 'pending'}
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+GEM_ROOT = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+Dir["#{GEM_ROOT}/spec/support/**/*.rb"].sort.each {|f| require f}
+
+require 'immutable-struct'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+  config.order = "random"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: immutable-struct
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Stitch Fix Engineering
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: Easily create value objects without the pain of Ruby's Struct (or its
+  setters)
+email:
+- jobs@stitchfix.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- immutable-struct.gemspec
+- lib/immutable-struct.rb
+- spec/immutable_struct_spec.rb
+- spec/spec_helper.rb
+homepage: http://technology.stitchfix.com
+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.2.0.rc.1
+signing_key: 
+specification_version: 4
+summary: Easily create value objects without the pain of Ruby's Struct (or its setters)
+test_files:
+- spec/immutable_struct_spec.rb
+- spec/spec_helper.rb