attire 0.1.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e5925a4cfc382fbdb58206a32e9b2c48952b5ce
-  data.tar.gz: 7ae88651bbceccaf71b924e657d186ce762e581b
+  metadata.gz: b1e1fc1f22a2213695656d10b09d2de54e340910
+  data.tar.gz: 0e10d06cf3402de661391eb894c5127f6a9f56fe
 SHA512:
-  metadata.gz: 6c22d2e332413f498157b1309dd24ac30902cf5e852a98249f011f55853728d76201a77d250b4073efd9abb30f37f9ac4acaba292aec9ab3c964fc98ff8457e1
-  data.tar.gz: 5e7fe15ae4b53d3db1064d82885000d1cfc07a96e63263c831968da1bf2244d97bef02ca352823997c1601d85d30d5cae7614160ef4cbb05b0c1ff0a049687d1
+  metadata.gz: 8878fced254c26d7f4520bb99547d88c96b5355b79200b8e3ace0c47e03c3c1e26c64b4ecfc435184c209138ffecb1f11c38876f249f33417a03abce178f7def
+  data.tar.gz: 76646d629df750287941eaad2e57a3884f236be29a0c77bc66eb7bd0bcc08730def009c0dbccefb66b9c0e32350cab641c07d176ee7b7e294b276f93dd427421

data/README.md

@@ -1,93 +1,107 @@
-# Attire
-
-[![Build Status](https://travis-ci.org/mushishi78/attire.svg?branch=master)](https://travis-ci.org/mushishi78/attire)
-[![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. Inspired by [attr_extras](https://github.com/barsoom/attr_extras).
-
-## Usage
-
-### `attr_init :foo, :bar, fizz: 15, pop: nil`
-
-Defines the following:
-
-``` ruby
-def initialize(foo, bar, opts = {})
-	@foo = foo
-	@bar = bar
-	@fizz = opts[:fizz] || 15
-	@pop = opts[:pop]
-end
-
-private
-
-attr_reader :foo, :bar, :fizz, :pop
-```
-
-Optional, splat and blocks arguments can also be defined:
-
-``` ruby
-attr_init :'opts = {}', :'*args', :'&block'
-```
-
-If a block is provided, it will be evaluated after initialization:
-
-``` ruby
-attr_init :foo do
-  @foo = foo ** 2
-end
-```
-
-### `attr_method :select, :bar`
-
-Defines the following:
-
-``` ruby
-def self.select(*args, &block)
-  new(*args, &block).select
-end
-
-attr_init :bar
-```
-
-This is useful for method objects/use cases:
-
-``` ruby
-class CheeseSpreader
-  attr_method :spread, :cheese, crackers_class: Jacobs
-
-  def spread
-    cracker = crackers_class.new
-    cracker.spreads << cheese
-    cracker
-  end
-end
-
-CheeseSpreader.spread(roquefort)
-```
-
-### `attr_query :foo?`
-
-Defines query `#foo?`, which is true if `foo` is truthy.
-
-## Installation
-
-Add to Gemfile:
-
-```ruby
-gem 'attire'
-```
-
-Require library:
-
-``` ruby
-require 'attire'
-```
-
-## Contributing
-
-1. Fork it ( https://github.com/[my-github-username]/attire/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
+# Attire
+
+[![Build Status](https://travis-ci.org/mushishi78/attire.svg?branch=master)](https://travis-ci.org/mushishi78/attire)
+[![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. Inspired by [attr_extras](https://github.com/barsoom/attr_extras).
+
+## attr_init
+
+``` ruby
+attr_init :foo, :bar, fizz: 15, pop: nil
+```
+
+Defines the following:
+
+``` ruby
+def initialize(foo, bar, opts = {})
+	@foo = foo
+	@bar = bar
+	@fizz = opts[:fizz]
+	@pop = opts[:pop]
+end
+
+private
+
+attr_reader :foo, :bar, :pop
+
+def fizz
+  @fizz ||= 15
+end
+```
+
+Optional, splat and blocks arguments can also be defined:
+
+``` ruby
+attr_init :'opts = {}', :'*args', :'&block'
+```
+
+If a block is provided, it will be evaluated after initialization:
+
+``` ruby
+attr_init :foo do
+  @foo = foo ** 2
+end
+```
+
+## attr_method
+
+``` ruby
+attr_method :select, :bar
+```
+
+Defines the following:
+
+``` ruby
+def self.select(*args, &block)
+  new(*args, &block).select
+end
+
+attr_init :bar
+```
+
+This is useful for method objects/use cases:
+
+``` ruby
+class CheeseSpreader
+  attr_method :spread, :cheese, crackers_class: Jacobs
+
+  def spread
+    cracker = crackers_class.new
+    cracker.spreads << cheese
+    cracker
+  end
+end
+
+CheeseSpreader.spread(roquefort)
+```
+
+## attr_query
+
+``` ruby
+attr_query :foo?
+```
+
+Defines query `#foo?`, which is true if `foo` is truthy.
+
+## Installation
+
+Add to Gemfile:
+
+```ruby
+gem 'attire'
+```
+
+Require library:
+
+``` ruby
+require 'attire'
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/attire/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

data/lib/attire/attr_init/arguments.rb

@@ -0,0 +1,57 @@
+require 'attire/core_ext/duplicable'
+require_relative 'arguments_checker'
+
+module Attire
+  module AttrInit
+    class Arguments
+      def initialize(arguments)
+        ArgumentsChecker.check(arguments)
+        @block = last_argument_with_prefix(arguments, '&')
+        @splat = last_argument_with_prefix(arguments, '*')
+        @names, @defaults = [], {}
+        arguments.each { |arg| extract_argument(arg) }
+        @arity_range = (min_arity..max_arity)
+        @getter_names = (names.flatten + [splat, block]).compact
+      end
+
+      attr_reader :names, :splat, :block, :defaults, :arity_range, :getter_names
+
+      private
+
+      def last_argument_with_prefix(arguments, prefix)
+        return unless arguments.last.to_s.start_with?(prefix)
+        arguments.pop.to_s[1..-1]
+      end
+
+      def extract_argument(arg)
+        return extract_hash(arg) if arg.is_a?(Hash)
+        return extract_optional(arg) if arg.to_s.include?('=')
+        extract_required(arg)
+      end
+
+      def extract_hash(hash)
+        names << hash.keys
+        defaults.merge!(hash)
+      end
+
+      def extract_optional(arg)
+        name, default = arg.to_s.split('=').map(&:strip)
+        names << name
+        defaults[name] = eval(default)
+      end
+
+      def extract_required(arg)
+        names << arg
+        @min_arity = names.length
+      end
+
+      def min_arity
+        @min_arity ||= 0
+      end
+
+      def max_arity
+        splat ? Float::INFINITY : names.length
+      end
+    end
+  end
+end

data/lib/attire/attr_init/arguments_checker.rb

@@ -0,0 +1,66 @@
+module Attire
+  module AttrInit
+    class ArgumentsChecker
+      def self.check(arguments)
+        new.check(arguments)
+      end
+
+      def check(arguments)
+        arguments.reverse.each_with_index do |arg, i|
+          @arg, @i = arg, i
+          type_check
+          block_check
+          splat_check
+          required_after_optional_check
+        end
+      end
+
+      private
+
+      attr_reader :arg, :i
+
+      TYPES = [Symbol, String, Hash]
+
+      def type_check
+        return if TYPES.include?(arg.class)
+        fail ArgumentError, 'Must be Symbol, String or Hash.'
+      end
+
+      def block_check
+        return unless block?
+        fail ArgumentError, 'Block arguments must be last' unless i == 0
+        @has_block = true
+      end
+
+      def splat_check
+        return unless splat?
+        return if i == (@has_block ? 1 : 0)
+        fail ArgumentError, \
+          'Splat arguments must come after required and optional arguments'
+      end
+
+      def required_after_optional_check
+        return if block? || splat? || hash?
+        return @has_requireds = true unless optional?
+        return unless @has_requireds
+        fail ArgumentError, 'Required arguments must come before optional'
+      end
+
+      def block?
+        arg.to_s.start_with?('&')
+      end
+
+      def splat?
+        arg.to_s.start_with?('*')
+      end
+
+      def hash?
+        arg.is_a?(Hash)
+      end
+
+      def optional?
+        arg.to_s.include?('=')
+      end
+    end
+  end
+end

data/lib/attire/attr_init/initializer.rb

@@ -0,0 +1,30 @@
+require_relative 'values_matcher'
+
+module Attire
+  module AttrInit
+    class Initializer
+      def initialize(arguments, after_initialize, opts = {})
+        @values_matcher = opts[:values_matcher] || ValuesMatcher.new(arguments)
+        @arity_range = arguments.arity_range
+        @after_initialize = after_initialize
+      end
+
+      def instance_initialize(instance, values, value_block)
+        arity_check(values)
+        values_matcher.match(values, value_block).each do |k, v|
+          instance.instance_variable_set("@#{k}", v)
+        end
+        instance.instance_exec(&after_initialize) if after_initialize
+      end
+
+      private
+
+      attr_reader :values_matcher, :arity_range, :after_initialize
+
+      def arity_check(values)
+        return if arity_range.include?(values.length)
+        fail ArgumentError, "wrong number of arguments (#{values.length} for #{arity_range})"
+      end
+    end
+  end
+end

data/lib/attire/attr_init/values_matcher.rb

@@ -0,0 +1,42 @@
+require 'forwardable'
+
+module Attire
+  module AttrInit
+    class ValuesMatcher
+      extend Forwardable
+
+      def initialize(arguments)
+        @arguments = arguments
+      end
+
+      def match(values, value_block)
+        @matched = {}
+        names.zip(values) { |n, v| n.is_a?(Array) ? set_from_hash(v) : set(n, v) }
+        set_splat(values)
+        set_block(value_block)
+        matched
+      end
+
+      private
+
+      attr_reader :arguments, :matched
+      def_delegators :arguments, :names, :splat, :block
+
+      def set(name, value)
+        matched[name] = value
+      end
+
+      def set_from_hash(values)
+        matched.merge!(values || {})
+      end
+
+      def set_splat(values)
+        matched[splat] = values[names.length..-1] || [] if splat
+      end
+
+      def set_block(value_block)
+        matched[block] = value_block if block
+      end
+    end
+  end
+end

data/lib/attire/attr_init.rb

@@ -1,94 +1,38 @@
-require 'attire/initializer'
+require 'attire/attr_init/arguments'
+require 'attire/attr_init/initializer'
 
 module Attire
-  class AttrInit
-    def self.apply(*args)
-      new(*args).apply
-    end
-
-    def initialize(klass, names, after_initialize)
-      @klass, @names, @after_initialize = klass, names, after_initialize
-    end
-
-    def apply
-      type_check
-      extract_splat_and_block_names
-      optional_arguments_check
-      instance_initialize = initializer.method(:instance_initialize)
-
-      klass.send(:define_method, :initialize) do |*values, &value_block|
-        instance_initialize.call(self, values, value_block)
+  module AttrInit
+    class << self
+      def apply(klass, args, after_initialize)
+        arguments = Arguments.new(args)
+        initializer = Initializer.new(arguments, after_initialize)
+        define_initializer(klass, initializer)
+        define_getters(klass, arguments)
       end
 
-      define_getters
-    end
-
-    private
-
-    attr_reader :klass, :names, :splat_name, :block_name, :after_initialize
+      private
 
-    def type_check
-      return if names.all? { |n| [Symbol, String, Hash].include?(n.class) }
-      fail ArgumentError, 'Must be Symbol, String or Hash.'
-    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 initializer
-      Initializer.new(names, splat_name, block_name, after_initialize)
-    end
-
-    def define_getters
-      getter_names.each do |name|
-        klass.send(:define_method, name) { instance_variable_get("@#{name}") }
+      def define_initializer(klass, initializer)
+        klass.send(:define_method, :initialize) do |*values, &value_block|
+          initializer.instance_initialize(self, values, value_block)
+        end
       end
-      klass.send(:private, *getter_names)
-    end
 
-    def getter_names
-      getter_names = names.map do |arg|
-        next arg.keys if arg.respond_to?(:keys)
-        next optional_name(arg) if optional?(arg)
-        arg
+      def define_getters(klass, arguments)
+        names = arguments.getter_names
+        names.each { |n| define_getter(klass, n, arguments.defaults[n]) }
+        klass.send(:private, *names)
       end
-      getter_names += [splat_name, block_name]
-      getter_names.flatten.compact
-    end
-
-    def last_name_with_prefix(prefix)
-      without_prefix(names.pop) if last_name_prefix?(prefix)
-    end
-
-    def without_prefix(symbol)
-      symbol.to_s[1..-1].to_sym
-    end
-
-    def last_name_prefix?(prefix)
-      names.last.to_s.start_with?(prefix)
-    end
 
-    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
-
-    def optional_arguments_check
-      start = names.find_index { |n| optional?(n) }
-      return unless start
-      return if names[start..-1].all? { |n| n.is_a?(Hash) || optional?(n) }
-      fail ArgumentError, 'Required arguments must come before optional'
-    end
-
-    def optional?(name)
-      name.to_s.include?('=')
-    end
-
-    def optional_name(name)
-      name.to_s.split('=')[0].strip
+      def define_getter(klass, name, default)
+        klass.send(:define_method, name) do
+          value = instance_variable_get("@#{name}")
+          return value unless value.nil? && !default.nil?
+          default = default.duplicable? ? default.dup : default
+          instance_variable_set("@#{name}", default)
+        end
+      end
     end
   end
 end

data/lib/attire.rb

@@ -1,24 +1,24 @@
-require 'attire/attr_init'
-
-module Attire
-  def attr_query(*names)
-    names.each do |name|
-      name = name.to_s
-      fail ArgumentError, "`#{name}?`, not `#{name}`." unless name.end_with?('?')
-      define_method(name) { !!send(name.chop) }
-    end
-  end
-
-  def attr_init(*names, &block)
-    AttrInit.apply(self, names, block)
-  end
-
-  def attr_method(verb, *names, &block)
-    define_singleton_method(verb) { |*a, &b| new(*a, &b).send(verb) }
-    attr_init(*names, &block)
-  end
-end
-
-class Module
-  include Attire
-end
+require 'attire/attr_init'
+
+module Attire
+  def attr_query(*names)
+    names.each do |name|
+      name = name.to_s
+      fail ArgumentError, "`#{name}?`, not `#{name}`." unless name.end_with?('?')
+      define_method(name) { !!send(name.chop) }
+    end
+  end
+
+  def attr_init(*args, &block)
+    AttrInit.apply(self, args, block)
+  end
+
+  def attr_method(verb, *args, &block)
+    define_singleton_method(verb) { |*a, &b| new(*a, &b).send(verb) }
+    attr_init(*args, &block)
+  end
+end
+
+class Module
+  include Attire
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attire
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Max White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-28 00:00:00.000000000 Z
+date: 2015-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -40,9 +40,12 @@ files:
 - README.md
 - lib/attire.rb
 - lib/attire/attr_init.rb
+- lib/attire/attr_init/arguments.rb
+- lib/attire/attr_init/arguments_checker.rb
+- lib/attire/attr_init/initializer.rb
+- lib/attire/attr_init/values_matcher.rb
 - lib/attire/core_ext/duplicable.rb
-- lib/attire/initializer.rb
-homepage: 
+homepage: https://github.com/mushishi78/attire
 licenses:
 - MIT
 metadata: {}

data/lib/attire/initializer.rb

@@ -1,92 +0,0 @@
-require 'attire/core_ext/duplicable'
-
-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|
-        next set_hash(name, value) if name.is_a?(Hash)
-        next set_optional(name, value) if optional?(name)
-        set_ivar(name, value)
-      end
-      set_splat
-      set_block
-    end
-
-    def set_hash(defaults, values)
-      values ||= {}
-      hash_check(values)
-      defaults.each do |name, default|
-        next set_ivar(name, values[name]) unless values[name].nil?
-        set_ivar(name, default.duplicable? ? default.dup : default)
-      end
-    end
-
-    def set_optional(name, value)
-      name, default = name.to_s.split('=').map(&:strip)
-      value = instance.instance_eval(default) if value.nil?
-      set_ivar(name, value)
-    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
-      last_required = names.reverse_each.find_index do |n|
-        !(optional?(n) || n.is_a?(Hash))
-      end
-      last_required ? names.length - last_required : 0
-    end
-
-    def max_arity
-      splat_name ? Float::INFINITY : names.length
-    end
-
-    def arity_range
-      @arity_range ||= (min_arity..max_arity)
-    end
-
-    def optional?(name)
-      name.to_s.include?('=')
-    end
-  end
-end