attr_extras 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: d86d1ce2f78e900f9dd4c9792df912f94ed6973f
-  data.tar.gz: 41d756b1d2b14f6f66ce1b8eb7e0127b4839d9b3
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjhmZWFmMjMzZDY4YmFmYWYyZDFjYjIyNzU1ZGJlYmFlMmYxNGEwMQ==
+  data.tar.gz: !binary |-
+    ZTI2NzNiMmEwZDRlNjM3ZjM5ODZiMDcyYTU0YWNmZmE0YTEyODNkOQ==
 SHA512:
-  metadata.gz: 5f4c36e7c979590d62a5a8fccc7f450eda9ec9cb1cd21466b8634c995b9bd2921bf1edbab33a09e85a7136f618d4e99ace7a3d8c70701420d216eb3b67695710
-  data.tar.gz: 4eb369edb50ea00c9bfdb36f78053cfdbabecd9ce826050fa8d588ede9942e72ebefa064ed2b05f10edaf4b4f58be2e9cf347919892c5d74dbee34312a6f45df
+  metadata.gz: !binary |-
+    MzE5YmQ3ZjBmYjY5MzY4OTczY2VkNzNiMDVkNDMxNzUyYmFkMzFlMmJmNTA5
+    MjYxMjJkZDE1YmJkYzdlNjM2NzIwOWZhMjc2OTUxYjBjNmNjN2RiZDEwODIy
+    YWVmZGE0MWZjOGY3NWFmNGNkODg5Mzk0NDllMGMzOWJkN2Q3ZGQ=
+  data.tar.gz: !binary |-
+    M2NkMWU1NjAxYTNkMjczY2VkYWEwMDMyODM5OGY0YjcxNDU4YjRlZWRkZmYy
+    MjZlYzM3NjgyOWVhMjg2NjMyNmJiZTk2OTdlNjk4ODFkZTU4Y2E2ZjFkNWY5
+    OTgxY2EwYjk0Nzc4MWNmYTc4MTBiZTM0ODQwNzllZTE5ZGY2OGI=

data/README.md

@@ -28,6 +28,10 @@ end
 
 This nicely complements Ruby's built-in `attr_accessor`, `attr_reader` and `attr_writer`.
 
+Supports positional arguments as well as optional and required hash arguments.
+
+Also provides conveniences for creating value objects, method objects and query methods.
+
 
 ## Usage
 
@@ -79,83 +83,59 @@ The `attr_initialize` notation notation for hash arguments is also supported: `v
 
 ### `method_object :fooable?, :foo`<br>
 
-Defines a `.fooable?` class method that takes one argument (`:foo`) and delegates to an instance method that can access `foo` as a private reader, useful for [method objects](http://refactoring.com/catalog/replaceMethodWithMethodObject.html).
-
-The `attr_initialize` notation notation for hash arguments is also supported: `method_object :fooable?, :foo, [:bar, :baz!]`
-
-You don't have to specify readers if you don't want them: `method_object :fooable?` is also valid.
-
-
-### `attr_id_query :foo?, :bar?`<br>
-Defines query methods like `foo?`, which is true iff `foo_id` is truthy. Goes well with Active Record.
-
+Defines a `.fooable?` class method that takes arguments (`foo`) and delegates to an instance method that can access those arguments as private readers.
 
-### `attr_query :foo?, :bar?`<br>
-Defines query methods like `foo?`, which is true iff `foo` is truthy.
+This is useful for [method objects](http://refactoring.com/catalog/replaceMethodWithMethodObject.html):
 
+``` ruby
+class PriceCalculator
+  method_object :calculate,
+    :order
 
-## Philosophy
+  def calculate
+    order.price * factor
+  end
 
-Findability is a core value.
-Hence the long name `attr_initialize`, so you see it when scanning for the initializer;
-and the enforced questionmarks with `attr_id_query :foo?`, so you can search for that method.
+  private
 
+  def factor
+    1 + rand
+  end
+end
+```
 
-## Example
+Shortcut for
 
 ``` ruby
-class MyClass
-  pattr_initialize :foo, :bar
-  attr_id_query :item?
-  attr_query :oof?
-
-  def oof
-    foo.reverse
-  end
+attr_initialize :foo
+attr_private :foo
 
-  def item_id
-    123
-  end
+def self.fooable?(foo)
+  new(foo).fooable?
 end
+```
 
-x = MyClass.new("Foo!", "Bar!")
-x.oof    # => "!ooF"
-x.foo    # NoMethodError: private method `foo' called.
-x.item?  # => true
-x.oof?   # => true
+The `attr_initialize` notation notation for hash arguments is also supported: `method_object :fooable?, :foo, [:bar, :baz!]`
 
+You don't have to specify readers if you don't want them: `method_object :fooable?` is also valid.
 
-class MyMethodObject
-  method_object :fooable?,
-    :foo
 
-  def fooable?
-    foo == :some_value
-  end
-end
+### `attr_id_query :foo?, :bar?`<br>
 
-MyMethodObject.fooable?(:some_value)     # => true
-MyMethodObject.fooable?(:another_value)  # => false
+Defines query methods like `foo?`, which is true if (and only if) `foo_id` is truthy. Goes well with Active Record.
 
 
-class MyHashyObject
-  attr_initialize :foo, [:bar, :baz]
-  attr_reader :bar
-end
+### `attr_query :foo?, :bar?`<br>
 
-x = MyHashyObject.new("Foo!", bar: "Bar!", baz: "Baz!")
-x.bar  # => "Bar!"
+Defines query methods like `foo?`, which is true if (and only if) `foo` is truthy.
 
 
-class MyValueObject
-  attr_value :foo, :bar
-end
+## Philosophy
+
+Findability is a core value.
+Hence the long name `attr_initialize`, so you see it when scanning for the initializer;
+and the enforced questionmarks with `attr_id_query :foo?`, so you can search for that method.
 
-x = MyValueObject.new(5, 10)
-x.foo  # => 5
-x.bar  # => 10
-x.foo = 20  # NoMethodError: undefined method `foo=''`
-```
 
 ## Why not use `Struct`?
 

data/lib/attr_extras/attr_initialize.rb

@@ -0,0 +1,57 @@
+class AttrExtras::AttrInitialize
+  def initialize(klass, names)
+    @klass, @names = klass, names
+  end
+
+  attr_reader :klass, :names
+  private :klass, :names
+
+  def apply
+    # The define_method block can't call our methods, so we need to make
+    # things available via local variables.
+    names = @names
+    validate_arity = method(:validate_arity)
+    set_ivar_from_hash = method(:set_ivar_from_hash)
+
+    klass.send(:define_method, :initialize) do |*values|
+      validate_arity.call(values.length)
+
+      names.zip(values).each do |name_or_names, value|
+        if name_or_names.is_a?(Array)
+          hash = value || {}
+
+          name_or_names.each do |name|
+            set_ivar_from_hash.call(self, name, hash)
+          end
+        else
+          name = name_or_names
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+  end
+
+  private
+
+  def validate_arity(provided_arity)
+    arity_without_hashes = names.count { |name| not name.is_a?(Array) }
+    arity_with_hashes    = names.length
+
+    unless (arity_without_hashes..arity_with_hashes).include?(provided_arity)
+      arity_range = [arity_without_hashes, arity_with_hashes].uniq.join("..")
+      raise ArgumentError, "wrong number of arguments (#{provided_arity} for #{arity_range})"
+    end
+  end
+
+  def set_ivar_from_hash(instance, name, hash)
+    if name.to_s.end_with?("!")
+      actual_name = name.to_s.chop.to_sym
+      value = hash.fetch(actual_name)
+    else
+      actual_name = name
+      value = hash[name]
+    end
+
+    instance.instance_variable_set("@#{actual_name}", value)
+  end
+end

data/lib/attr_extras/attr_query.rb

@@ -0,0 +1,13 @@
+module AttrExtras::AttrQuery
+  def self.define_with_suffix(klass, suffix, *names)
+    names.each do |name|
+      name = name.to_s
+
+      raise "#{__method__} wants `#{name}?`, not `#{name}`." unless name.end_with?("?")
+
+      klass.send(:define_method, name) do  # def foo?
+        !!send("#{name.chop}#{suffix}")    #   !!send("foo_id")
+      end                                  # end
+    end
+  end
+end

data/lib/attr_extras/utils.rb

@@ -0,0 +1,5 @@
+module AttrExtras::Utils
+  def self.flat_names(names)
+    names.flatten.map { |x| x.to_s.sub(/!\z/, "") }
+  end
+end

data/lib/attr_extras/version.rb

@@ -1,3 +1,3 @@
 module AttrExtras
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
 end

data/lib/attr_extras.rb

@@ -1,40 +1,12 @@
 require "attr_extras/version"
+require "attr_extras/attr_initialize"
+require "attr_extras/attr_query"
+require "attr_extras/utils"
 
 module AttrExtras
   module ClassMethods
     def attr_initialize(*names)
-      min_arity = names.count { |n| not n.is_a?(Array) }
-      max_arity = names.length
-
-      define_method(:initialize) do |*values|
-        provided_arity = values.length
-
-        unless (min_arity..max_arity).include?(provided_arity)
-          arity_range = [min_arity, max_arity].uniq.join("..")
-          raise ArgumentError, "wrong number of arguments (#{provided_arity} for #{arity_range})"
-        end
-
-        names.zip(values).each do |name_or_names, value|
-          if name_or_names.is_a?(Array)
-            value ||= {}
-
-            name_or_names.each do |name|
-              if name.to_s.end_with?("!")
-                actual_name = name.to_s.chop.to_sym
-                actual_value = value.fetch(actual_name)
-              else
-                actual_name = name
-                actual_value = value[name]
-              end
-
-              instance_variable_set("@#{actual_name}", actual_value)
-            end
-          else
-            name = name_or_names
-            instance_variable_set("@#{name}", value)
-          end
-        end
-      end
+      AttrInitialize.new(self, names).apply
     end
 
     def attr_private(*names)
@@ -44,12 +16,12 @@ module AttrExtras
 
     def pattr_initialize(*names)
       attr_initialize(*names)
-      attr_private *attr_flat_names(names)
+      attr_private *Utils.flat_names(names)
     end
 
     def vattr_initialize(*names)
       attr_initialize(*names)
-      attr_value *attr_flat_names(names)
+      attr_value *Utils.flat_names(names)
     end
 
     def attr_value(*names)
@@ -71,29 +43,11 @@ module AttrExtras
     end
 
     def attr_query(*names)
-      attr_query_with_suffix(*names, "")
+      AttrQuery.define_with_suffix(self, "", *names)
     end
 
     def attr_id_query(*names)
-      attr_query_with_suffix(*names, "_id")
-    end
-
-    private
-
-    def attr_flat_names(names)
-      names.flatten.map { |x| x.to_s.sub(/!\z/, "") }
-    end
-
-    def attr_query_with_suffix(*names, suffix)
-      names.each do |name|
-        name = name.to_s
-
-        raise "#{__method__} wants `#{name}?`, not `#{name}`." unless name.end_with?("?")
-
-        define_method(name) do             # def foo?
-          !!send("#{name.chop}#{suffix}")  #   !!send("foo_id")
-        end                                # end
-      end
+      AttrQuery.define_with_suffix(self, "_id", *names)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attr_extras
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Henrik Nyh
@@ -15,14 +15,14 @@ dependencies:
   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: 
@@ -40,6 +40,9 @@ files:
 - Rakefile
 - attr_extras.gemspec
 - lib/attr_extras.rb
+- lib/attr_extras/attr_initialize.rb
+- lib/attr_extras/attr_query.rb
+- lib/attr_extras/utils.rb
 - lib/attr_extras/version.rb
 - script/test
 - spec/attr_extras_spec.rb
@@ -53,17 +56,17 @@ 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
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Takes some boilerplate out of Ruby with methods like attr_initialize.