attire 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64462f8404d14584ebdfed3fead9ce4a7d0e250e
-  data.tar.gz: 480ae9e4232ff1226c98af84fec1ad78e538b5b6
+  metadata.gz: f2bfbf4841ab811cd44ca5b6cdc0e1f2b7684edd
+  data.tar.gz: 3b5c032e8ace9ffebb12a3d4b05cf34c6c5165b2
 SHA512:
-  metadata.gz: 38df5f2ded5aec66f5a6275d2922da706153223620815afb0c06ca8b2f3abe4c11c78b8626cf5fe2f231841b14eadd13874b4a208285b600c9ee888835cd3074
-  data.tar.gz: 7f1f0b736e8b6f7e3390a9d50ad374b304e82f7c2d44dd7803a05532e65ab116f85164c226945023af42db03b59f567c2f33667f9378dc60da0563eac79571ea
+  metadata.gz: c3e7f83d80850d61a9e209840546656c90830d1c18928cc647520e434d9992337d83de6b455636f34249b4a763d0b3b8c7264d807e3fae07b4224211aa4cb38b
+  data.tar.gz: 2b3e84746a21c8668b55cb96a069f4da96f4d33052caca4d1340e32ad6c079d2dc36fccb8b5f7115e44094f0f6957999b90a99efd92df5f136a0abfcd6bc73f9

data/README.md

@@ -2,34 +2,50 @@
 
 [![Gem Version](https://badge.fury.io/rb/attire.svg)](http://badge.fury.io/rb/attire)
 
-Convenience methods to remove some boiler plate in defining classes. Heavily inspired by [attr_extras](https://github.com/barsoom/attr_extras).
+Convenience methods to remove some boiler plate in defining classes. Inspired by [attr_extras](https://github.com/barsoom/attr_extras).
 
 ## Usage
 
 ### `attr_init :foo, :bar, fizz: 15, pop: nil`
 
-Defines the following initializer:
+Defines the following:
 
 ``` ruby
-def initializer(foo, bar, opts = {})
+def initialize(foo, bar, opts = {})
 	@foo = foo
 	@bar = bar
 	@fizz = opts[:fizz] || 15
 	@pop = opts[:pop]
 end
+
+private
+
+attr_reader :foo, :bar, :fizz, :pop
+```
+
+Splat arguments and blocks can also be defined:
+
+``` ruby
+attr_init :'*args', :'&block'
 ```
 
-`attr_init` can also accept a block which will be invoked after initialization.
+If a block is provided, it will be evaluated after initialization:
+
+``` ruby
+attr_init :foo do
+  @foo = foo ** 2
+end
+```
 
 ### `attr_method :select, :bar`
 
-Shortcut for:
+Defines the following:
 
 ``` ruby
 attr_init :bar
 
-def self.select(bar)
-  new(bar).select
+def self.select(*args, &block)
+  new(*args, &block).select
 end
 ```
 
@@ -40,46 +56,31 @@ class CheeseSpreader
   attr_method :spread, :cheese, crackers: Jacobs.new
 
   def spread
-  raise CheeseError unless cheese.is_a?(Cheddar)
-  cheese.spread_on(crackers)
+    raise CheeseError unless cheese.is_a?(Cheddar)
+    cheese.spread_on(crackers)
   end
 end
 
-...
-
-my_cheese = Roquefort.new
-CheeseSpreader.spread(my_cheese) # CheeseError
+CheeseSpreader.spread(Roquefort.new) # CheeseError
 ```
 
 ### `attr_query :foo?`
 
-Defines query methods like `foo?`, which is true if `foo` is truthy.
-
-### `fattr_init :foo`
-
-Calls `self.freeze` after initialization to make object immutable.
-
-### `fattr_method :foo`
-
-Same as `fattr_init`, only for `attr_method`.
-
+Defines query `foo?`, which is true if `foo` is truthy.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add to Gemfile:
 
 ```ruby
 gem 'attire'
 ```
 
-And then execute:
-
-  $ bundle
-
-Or install it yourself as:
-
-  $ gem install attire
+Require library:
 
+``` ruby
+require 'attire'
+```
 
 ## Contributing
 

data/lib/attire/attr_init.rb

@@ -1,76 +1,74 @@
+require 'attire/initializer'
+
 module Attire
   class AttrInit
     def self.apply(*args)
       new(*args).apply
     end
 
-    def initialize(klass, args, block)
-      @klass, @args, @block = klass, args, block
+    def initialize(klass, names, after_initialize)
+      @klass, @names, @after_initialize = klass, names, after_initialize
     end
 
     def apply
       type_check
-      init = method(:init)
-      klass.send(:define_method, :initialize) { |*values| init.call(self, values) }
+      extract_splat_and_block_names
+      instance_initialize = initializer.method(:instance_initialize)
+
+      klass.send(:define_method, :initialize) do |*values, &value_block|
+        instance_initialize.call(self, values, value_block)
+      end
+
       define_getters
     end
 
     private
 
-    attr_reader :klass, :args, :block, :instance, :values
+    attr_reader :klass, :names, :splat_name, :block_name, :after_initialize
 
-    def init(instance, values)
-      @instance, @values = instance, values
-      arity_check
-      set_variables
-      instance.instance_eval(&block) if block
+    def type_check
+      return if names.all? { |n| [Symbol, Hash].include?(n.class) }
+      fail ArgumentError, 'Must be Symbol or Hash.'
     end
 
-    def set_variables
-      args.zip(values).each do |arg, value|
-        next set_variable(arg, value) if arg.is_a?(Symbol)
-        value = {} if value.nil?
-        hash_check(value)
-        arg.each { |k, v| set_variable(k, value[k] || v) }
-      end
+    def extract_splat_and_block_names
+      @block_name = last_name_with_prefix('&')
+      @splat_name = last_name_with_prefix('*')
+      excess_splat_and_block_names_check
     end
 
-    def define_getters
-      getter_names.each do |arg|
-        klass.send(:define_method, arg) { instance_variable_get("@#{arg}") }
-        klass.send(:private, arg)
-      end
+    def initializer
+      Initializer.new(names, splat_name, block_name, after_initialize)
     end
 
-    def type_check
-      return if args.all? { |a| [Symbol, Hash].include?(a.class) }
-      fail ArgumentError, 'Must be Symbol or Hash.'
-    end
-
-    def arity_check
-      return if arity_range.include?(values.length)
-      fail ArgumentError, "wrong number of arguments (#{values.length} for #{arity_range})"
+    def define_getters
+      getter_names.each do |name|
+        klass.send(:define_method, name) { instance_variable_get("@#{name}") }
+      end
+      klass.send(:private, *getter_names)
     end
 
-    def hash_check(value)
-      return if value.is_a?(Hash)
-      fail ArgumentError, "#{value} should be Hash."
+    def getter_names
+      getter_names = names.map { |arg| arg.respond_to?(:keys) ? arg.keys : arg }
+      getter_names += [splat_name, block_name]
+      getter_names.flatten.compact
     end
 
-    def min_arity
-      args.last.is_a?(Hash) ? args.length - 1 : args.length
+    def last_name_with_prefix(prefix)
+      without_prefix(names.pop) if last_name_prefix?(prefix)
     end
 
-    def arity_range
-      @arity_range ||= (min_arity..args.length)
+    def without_prefix(symbol)
+      symbol.to_s[1..-1].to_sym
     end
 
-    def set_variable(name, value)
-      instance.instance_variable_set("@#{name}", value)
+    def last_name_prefix?(prefix)
+      names.last.to_s.start_with?(prefix)
     end
 
-    def getter_names
-      args.map { |arg| arg.respond_to?(:keys) ? arg.keys : arg }.flatten
+    def excess_splat_and_block_names_check
+      return if names.none? { |n| n.to_s.start_with?('&', '*') }
+      fail ArgumentError, "Splat and Block arguments must be last"
     end
   end
 end

data/lib/attire/initializer.rb

@@ -0,0 +1,72 @@
+module Attire
+	class Initializer
+		def initialize(names, splat_name, block_name, after_initialize)
+			@names = names
+			@splat_name = splat_name
+			@block_name = block_name
+			@after_initialize = after_initialize
+		end
+
+		def instance_initialize(instance, values, value_block)
+      @instance, @values, @value_block = instance, values, value_block
+      arity_check
+      set_ivars
+      instance.instance_eval(&after_initialize) if after_initialize
+    end
+
+    private
+
+    attr_reader :names, :splat_name, :block_name, :after_initialize,
+    						:instance, :values, :value_block
+
+    def set_ivars
+      names.zip(values).each do |name, value|
+        name.is_a?(Symbol) ? set_ivar(name, value) : set_hash(name, value)
+      end
+      set_splat
+      set_block
+    end
+
+    def set_hash(defaults, values)
+      values ||= {}
+      hash_check(values)
+      defaults.each { |name, default| set_ivar(name, values[name] || default) }
+    end
+
+    def set_splat
+      return unless splat_name
+      value_splat = values[names.length..values.length] || []
+      set_ivar(splat_name, value_splat)
+    end
+
+    def set_block
+      set_ivar(block_name, value_block) if block_name
+    end
+
+    def set_ivar(name, value)
+      instance.instance_variable_set("@#{name}", value)
+    end
+
+    def arity_check
+      return if arity_range.include?(values.length)
+      fail ArgumentError, "wrong number of arguments (#{values.length} for #{arity_range})"
+    end
+
+    def hash_check(value)
+      return if value.is_a?(Hash)
+      fail ArgumentError, "#{value} should be Hash."
+    end
+
+    def min_arity
+      names.last.is_a?(Hash) ? names.length - 1 : names.length
+    end
+
+    def max_arity
+      splat_name ? Float::INFINITY : names.length
+    end
+
+    def arity_range
+      @arity_range ||= (min_arity..max_arity)
+    end
+	end
+end

data/lib/attire.rb

@@ -9,25 +9,13 @@ module Attire
     end
   end
 
-  def attr_init(*args, &b)
-    AttrInit.apply(self, args, b)
+  def attr_init(*names, &b)
+    AttrInit.apply(self, names, b)
   end
 
-  def attr_method(verb, *args, &b)
-    define_singleton_method(verb) { |*a| new(*a).send(verb) }
-    attr_init(*args, &b)
-  end
-
-  def fattr_init(*args, &b)
-    attr_init(*args) do
-      instance_eval(&b) if b
-      freeze
-    end
-  end
-
-  def fattr_method(verb, *args, &b)
-    define_singleton_method(verb) { |*a| new(*a).send(verb) }
-    fattr_init(*args, &b)
+  def attr_method(verb, *names, &b)
+    define_singleton_method(verb) { |*a, &b| new(*a, &b).send(verb) }
+    attr_init(*names, &b)
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attire
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Max White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-08 00:00:00.000000000 Z
+date: 2015-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -40,6 +40,7 @@ files:
 - README.md
 - lib/attire.rb
 - lib/attire/attr_init.rb
+- lib/attire/initializer.rb
 homepage: 
 licenses:
 - MIT