attire 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a422961944b405505f20ccd99b7cf098378f18bf
-  data.tar.gz: 84b4261dca389bb26a7b52ad9f0981c2425dfafd
+  metadata.gz: e47510ce77fba871c171411ee89810f79bbe8231
+  data.tar.gz: 1ed7fbacff39b565ce85235d25e376941006021f
 SHA512:
-  metadata.gz: 22c26d505363455eafd750f6c385201d1eab0133f9b178f3b98c79fe31d504f8b2aa23d5aff4ceb512c8e3f8ba3596670dc6a3f2f4b6f4aa658a9a21cd0e5edc
-  data.tar.gz: 10ab969e34aff9b34188334d70d1dd8976fcb25ed5ea7e21aa0a437f139b0a70826dcdb14333b99046314c2afd60c456a0a16b0f16ba01abc8eb555ff9fff9e8
+  metadata.gz: 08e1829aecf20e6405dbcc3f2189a097f13cf8368de2770095857fd6968d02491106f0c52fba094b9d6c5a8cd50f8f4f885c11d1391440f8acd92fa5c2590d5c
+  data.tar.gz: 1c7084866f5e17483c32ed4fa9a20810d57b1aa5904909dd2e2712e369d85a9821e6addbc3b6dea03717c58c4e8d6215ca6d39e0a589ed6b17b1cc471a0a1203

data/README.md

@@ -3,87 +3,53 @@
 [![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).
+Mixins to remove some boiler plate in defining classes.
 
-## attr_init
+**N.B. This is the README for version 2.0.0. Major changes have been made. For previous versions please consult the tagged commit.**
 
-``` ruby
-attr_init :foo, :bar, fizz: 15, pop: nil
-```
+## Initializer
 
-Defines the following:
+`Attire::Initializer` extends a subsequent initialize method so that all it's parameters are assigned to instance variables and they can all be reached from private getters. For example:
 
 ``` ruby
-def initialize(foo, bar, opts = {})
-	@foo = foo
-	@bar = bar
-	@fizz = opts[:fizz]
-	@pop = opts[:pop]
-end
+require 'attire'
 
-private
+class MyClass
+  extend Attire::Initializer
 
-attr_reader :foo, :bar, :pop
+  def initialize(foo:, bar: 24)
+    @bar = bar * 2
+  end
 
-def fizz
-  @fizz ||= 15
+  def result
+    foo + bar
+  end
 end
-```
 
-Optional, splat and blocks arguments can also be defined:
-
-``` ruby
-attr_init :'opts = {}', :'*args', :'&block'
+my_instance = MyClass.new(foo: 50)
+my_instance.result # 98
 ```
 
-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
-```
+## MethodObject
 
-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:
+`Attire::MethodObject` does the same as `Attire::Initializer` but it also adds a singleton method that creates an instance and then calls an instance method. This is useful for objects that are designed to do one task. For example:
 
 ``` ruby
 class CheeseSpreader
-  attr_method :spread, :cheese, crackers_class: Jacobs
+  extend Attire::MethodObject.new(:spread)
+
+  def initialize(cheese, cracker: Jacobs.new)
+  end
 
   def spread
-    cracker = crackers_class.new
     cracker.spreads << cheese
     cracker
   end
 end
 
-CheeseSpreader.spread(roquefort)
+CheeseSpreader.spread(:roquefort)
 ```
 
-## attr_query
-
-``` ruby
-attr_query :foo?
-```
-
-Defines query `#foo?`, which is true if `foo` is truthy.
-
 ## Installation
 
 Add to Gemfile:
@@ -92,11 +58,9 @@ Add to Gemfile:
 gem 'attire'
 ```
 
-Require library:
+## Inspirations
 
-``` ruby
-require 'attire'
-```
+* [attr_extras](https://github.com/barsoom/attr_extras).
 
 ## Contributing
 

data/lib/attire.rb

@@ -1,24 +1,2 @@
-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)
-    include AttrInit.new(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
+require 'attire/initializer'
+require 'attire/method_object'

data/lib/attire/initializer.rb

@@ -0,0 +1,49 @@
+module Attire
+  module Initializer
+    def self.extended(base)
+      base.class.instance_variable_set(:@_added, false)
+    end
+
+    def method_added(method_name)
+      return super unless method_name == :initialize && !added?
+      method = instance_method(:initialize)
+      names = method.parameters.map(&:last)
+      add_initialize(method, names)
+      add_getters(names)
+      self.added = true
+      super
+    end
+
+    private
+
+    def added?
+      self.class.instance_variable_get(:@_added)
+    end
+
+    def added=(added)
+      self.class.instance_variable_set(:@_added, added)
+    end
+
+    def add_initialize(method, names)
+      initialize_line = initialize_line(method)
+      set_ivars = names.map { |name| "@#{name} = #{name}\n" }.join
+
+      initializer = Module.new do
+        class_eval "#{initialize_line}#{set_ivars}super\nend\n"
+      end
+      prepend initializer
+    end
+
+    def initialize_line(method)
+      file, endline = *method.source_location
+      File.readlines(file)[0..endline].reverse.each do |line|
+        return line if line.include?('initialize')
+      end
+    end
+
+    def add_getters(names)
+      attr_reader(*names)
+      private(*names)
+    end
+  end
+end

data/lib/attire/method_object.rb

@@ -0,0 +1,12 @@
+require_relative 'initializer'
+
+module Attire
+  module MethodObject
+    def self.new(verb)
+      Module.new do
+        define_singleton_method(:extended) { |base| base.extend Initializer }
+        define_method(verb) { |*a, **k, &b| new(*a, **k, &b).send(verb) }
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attire
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Max White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-03 00:00:00.000000000 Z
+date: 2015-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -39,12 +39,8 @@ files:
 - LICENSE.txt
 - 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/instance_methods.rb
-- lib/attire/attr_init/values_matcher.rb
-- lib/attire/core_ext/duplicable.rb
+- lib/attire/initializer.rb
+- lib/attire/method_object.rb
 homepage: https://github.com/mushishi78/attire
 licenses:
 - MIT
@@ -68,5 +64,5 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Convenience methods to remove some boiler plate in defining classes.
+summary: Mixins to remove some boiler plate in defining classes.
 test_files: []

data/lib/attire/attr_init.rb

@@ -1,24 +0,0 @@
-require 'attire/attr_init/arguments_checker'
-require 'attire/attr_init/arguments'
-require 'attire/attr_init/values_matcher'
-require 'attire/attr_init/instance_methods'
-
-module Attire
-  module AttrInit
-    def self.new(args, after_block)
-      ArgumentsChecker.check(args)
-      arguments = Arguments.new(args)
-      values_matcher = ValuesMatcher.new(arguments)
-      getters, defaults = arguments.getters, arguments.defaults
-
-      Module.new do
-        include InstanceMethods
-        define_method(:_arguments) { arguments }
-        define_method(:_after_block) { after_block }
-        define_method(:_values_matcher) { values_matcher }
-        getters.each { |n| define_method(n) { _get_attribute(n, defaults[n]) } }
-        private(*getters)
-      end
-    end
-  end
-end

data/lib/attire/attr_init/arguments.rb

@@ -1,55 +0,0 @@
-require 'attire/core_ext/duplicable'
-
-module Attire
-  module AttrInit
-    class Arguments
-      def initialize(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)
-        @getters = (names.flatten + [splat, block]).compact
-      end
-
-      attr_reader :names, :splat, :block, :defaults, :arity_range, :getters
-
-      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

@@ -1,66 +0,0 @@
-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)
-        msg = 'Splat arguments must come after required and optional arguments'
-        fail ArgumentError, msg
-      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/instance_methods.rb

@@ -1,37 +0,0 @@
-module Attire
-  module AttrInit
-    module InstanceMethods
-      def initialize(*values, &value_block)
-        _arity_check(values)
-        _match(values, value_block).each { |k, v| instance_variable_set("@#{k}", v) }
-        instance_exec(&_after_block) if _after_block
-      end
-
-      private
-
-      def _arity_check(values)
-        return if _arity_range.include?(values.length)
-        msg = "wrong number of arguments (#{values.length} for #{_arity_range})"
-        fail ArgumentError, msg
-      end
-
-      def _get_attribute(name, default)
-        value = instance_variable_get("@#{name}")
-        return value unless value.nil? && !default.nil?
-        instance_variable_set("@#{name}", _duped_default(default))
-      end
-
-      def _duped_default(default)
-        default.duplicable? ? default.dup : default
-      end
-
-      def _match(*args)
-        _values_matcher.match(*args)
-      end
-
-      def _arity_range
-        _arguments.arity_range
-      end
-    end
-  end
-end

data/lib/attire/attr_init/values_matcher.rb

@@ -1,42 +0,0 @@
-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/core_ext/duplicable.rb

@@ -1,48 +0,0 @@
-class Object
-  def duplicable?
-    true
-  end
-end
-
-class NilClass
-  def duplicable?
-    false
-  end
-end
-
-class FalseClass
-  def duplicable?
-    false
-  end
-end
-
-class TrueClass
-  def duplicable?
-    false
-  end
-end
-
-class Symbol
-  def duplicable?
-    false
-  end
-end
-
-class Numeric
-  def duplicable?
-    false
-  end
-end
-
-require 'bigdecimal'
-class BigDecimal
-  def duplicable?
-    true
-  end
-end
-
-class Method
-  def duplicable?
-    false
-  end
-end