procme 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MThlMjQxM2JhNmQ0YjZlMGFhNDQ4ZTZmODM0NDM4MDA2ZjMwYTM1ZA==
+    NjZiNzFlNzI2YWUxYzhkZWFkYzJiMDZlMjU2ZTBmNTYxZTc4ZWZlNg==
   data.tar.gz: !binary |-
-    ZmExNWYyYzI0YjM3NmM3ZjliOTRlNWRlNjgwMDJiMzQ4YzI2ZWY1Zg==
+    ZTk3ZjUyMDhkZmY0NTVkMzAyODc4MzBmMzk3NTg5OThhMjIzMDZlMw==
 SHA512:
   metadata.gz: !binary |-
-    YTJiZmVkZjFmMTFhN2UwODM2YWIyZjJjYTJiZDFjMDE3YTYyNzg1NjkzYzUy
-    NDZmYTJjYWYwOTYwNmJjYmFmYmE0MjZjYjhkZDdhZjg1NjlmZTFlZjNjNTQ2
-    MDMwMDdlNjNlZDQzMjMyYzAwNWE3MTZmNjc1OTY5ZWRhYmI3NzU=
+    MDgzNzIyYWZjNDA1M2YzMGE2ZjFkYTVjNDEyNmUxZjQwNDYxYjMwODI0OGY1
+    MTk2M2IxNGQ2MzAxOTA4MTViNzU5ZGYxNTdmMDA4YWI5ZDJiMTM5MmJmYjM3
+    NTU3MWNlNThjODhhOWU1YjMzZDE2ZDkzMGIxYmQ1ODVjZjA1ODM=
   data.tar.gz: !binary |-
-    NzYzMTZmNGM2M2VlZmVmZGZhOWNlM2M3NjEzNjkyZDdkOTY1ZDE5ZTJjNjk2
-    NjZjNDU4ZDBjNDM1YTNkN2M2MmZmZjUwZjBkMmRhYTA1MTJiYWFiYTZjZTVm
-    NjdmZTZlMTI0YzFlYTAzMzEwN2I1NWY1MTNmM2NhMzUyOGY0ODg=
+    ZjA2MzNmZmJjZjQwZWE5NTg2M2U2Y2Q2NmFmN2M0NmI1ZDczN2Y3YjE4NWU1
+    ZGUxZjFlODBhNDRmNTNmYjMwMjE2NzQ5MDVhYjEzMjBmN2E0Njc3MDVjYTJj
+    NDlkYjAzZWU2OGYzYzQyOTkyMGU1YzI5YjZiNDAzMTA2YTI2MWE=

data/.yardopts

@@ -0,0 +1,2 @@
+lib/procme.rb
+--no-private

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-15 Victor 'Zverok' Shepelev
+
+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.md

@@ -1,19 +1,34 @@
 # ProcMe
 
+[![Gem Version](https://badge.fury.io/rb/procme.svg)](http://badge.fury.io/rb/procme)
+
 ## Install
-With Bundler (brand new and yet unpublished to RubyGems):
+With Bundler:
 
+```ruby
+gem 'procme'
 ```
-gem 'procme', git: 'git://github.com/zverok/procme.git'
+
+in your Gemfile, then `bundle install`.
+
+Or without:
 ```
+gem install procme
+```
+
+[YARD docs](http://www.rubydoc.info/gems/procme)
 
 ## Usage
 
 ```ruby
-# Giving you have
+# Given you have
 class Person < Struct.new(:name, :age, :gender)
   def greet(who)
-    puts "#{name}: Hello, #{who}!"
+    "#{name}: Hello, #{who}!"
+  end
+
+  def greet!(who)
+    puts greet(name)
   end
 
   def inspect
@@ -48,12 +63,25 @@ p people.map(&set(gender: 'female'))
 # => [#<John, female, 30>, #<Jane, female, 23>, #<Jake, female, 48>, #<Judith, female, 16>]
 
 # ProcMe::call(method: args) - bulk call method with arguments:
-people.each(&call(greet: 'Ellis'))
+people.each(&call(greet!: 'Ellis'))
 # Output:
 #   John: Hello, Ellis!
 #   Jane: Hello, Ellis!
 #   Jake: Hello, Ellis!
 #   Judith: Hello, Ellis!
+
+# also works with #map:
+people.map(&call(greet: 'Ellis'))
+# => ["John: Hello, Ellis!", "Jane: Hello, Ellis!", "Jake: Hello, Ellis!", "Judith: Hello, Ellis!"]
+
+# ...and with several arguments:
+p people.map(&:name).map(&call(sub: ['J', 'F']))
+# => ["Fohn", "Fane", "Fake", "Fudith"]
+
+# ...and even several method you can call!
+p people.map(&:name).map(&call(:downcase, :'+' => ', hello'))
+# => [["john", "John, hello"], ["jane", "Jane, hello"], ["jake", "Jake, hello"], ["judith", "Judith, hello"]]
+# Note that each method call is performed on ORIGINAL object
 ```
 
 ## Rationale
@@ -94,3 +122,37 @@ P = ProcMe # to be short
 
 people.select(&P.fltr(gender: 'female'))
 ```
+
+## Should you use it?
+
+Frankly, I don't know. Things that mimic core language features can be
+extremely useful, yet potentially they make your code more obscure for
+reader. Though I think that ProcMe's syntax is pretty self-explanatory,
+you colleagues may have other opinion.
+
+As for me, since invention of this little thingy I've found it extremely
+handy and useful.
+
+## Small gotchas
+
+`ProcMe.fltr` uses `#===` while comparing values. This way you can filter
+strings by regular expressions or numbers by ranges. One counterintuitive
+things is going on when you try to filter by object class:
+
+```ruby
+['test', 'me'].select(&fltr(class: String)) # => []
+```
+
+It's because you should check object itself, not its class, to match with
+`===`. The solution is simple:
+
+```ruby
+['test', 'me'].select(&fltr(itself: String)) # => []
+```
+
+`#itself` method is available in Ruby >= 2.0, and easily backported to
+earlier versions.
+
+## License
+
+MIT

data/examples/example.rb

@@ -1,10 +1,14 @@
 # encoding: utf-8
 require_relative '../lib/procme'
 
-# Giving you have
+# Given you have
 class Person < Struct.new(:name, :age, :gender)
   def greet(who)
-    puts "#{name}: Hello, #{who}!"
+    "#{name}: Hello, #{who}!"
+  end
+
+  def greet!(who)
+    puts greet(name)
   end
 
   def inspect
@@ -39,9 +43,22 @@ p people.map(&set(gender: 'female'))
 # => [#<John, female, 30>, #<Jane, female, 23>, #<Jake, female, 48>, #<Judith, female, 16>]
 
 # ProcMe::call(method: [args]) - bulk call method with arguments:
-people.each(&call(greet: 'Ellis'))
+people.each(&call(greet!: 'Ellis'))
 # Output:
 #   John: Hello, Ellis!
 #   Jane: Hello, Ellis!
 #   Jake: Hello, Ellis!
 #   Judith: Hello, Ellis!
+
+# also works with #map:
+p people.map(&call(greet: 'Ellis'))
+# => ["John: Hello, Ellis!", "Jane: Hello, Ellis!", "Jake: Hello, Ellis!", "Judith: Hello, Ellis!"]
+
+# ...and with several arguments:
+p people.map(&:name).map(&call(sub: ['J', 'F']))
+# => ["Fohn", "Fane", "Fake", "Fudith"]
+
+# ...and even several method you can call!
+p people.map(&:name).map(&call(:downcase, :'+' => ', hello'))
+# => [["john", "John, hello"], ["jane", "Jane, hello"], ["jake", "Jake, hello"], ["judith", "Judith, hello"]]
+# Note that each method call is performed on ORIGINAL object

data/lib/procme.rb

@@ -1,7 +1,70 @@
 # encoding: utf-8
-# ProcMe: DRY and clean blocks for your code
+
+# ProcMe is DRY and clean blocks for your code.
+#
+# It provides four methods:
+#
+# {#fltr} - checks object attribute values
+#  
+#   ['test', 'me', 'please'].select(&fltr(length: 4))
+#   # => ['test']
+#
+# {#get} - get object attribute values
+# 
+#   ['test', 'me', 'please'].map(&get(:upcase, :length))
+#   # => [['TEST', 4], ['ME', 2'], ['PLEASE', 6]]
+#
+# {#call} - call methods on object
+#
+#   ['test', 'me', 'please'].map(&call(gsub: ['e', '*']))
+#   # => ['t*st', 'm*', 'pl*as*']
+#
+# {#set} - set object attribute values
+# 
+#   S = Struct.new(:name)
+#   arr = [S.new('test'), S.new('me')]
+#   arr.each(&set(name: 'please'))
+#   arr # => [#<struct S name="please">, #<struct S name="please">]
+# 
+# You can use the module as is:
+#
+#   ['test', 'me', 'please'].select(&ProcMe.fltr(length: 4))
+#
+# or include it and then use:
+#
+#   include ProcMe
+#
+#   ['test', 'me', 'please'].select(&fltr(length: 4))
+#
+#
 module ProcMe
-  def filter(hash)
+  # Constructs block, able to check objects attribute values
+  #
+  # @param attrs [Hash] hash of !{attribute name => value}
+  # @return [Proc] block accepting any object and returning +true+ or
+  #   +false+
+  #
+  # Use it like this:
+  #
+  #   some_array.select(&fltr(attr: value, other_attr: other_value))
+  #
+  # values are checked with +#===+ method, so you can do something like:
+  #
+  #   ['some', 'strings'].select(&fltr(length: 3..5)) # => ['some']
+  #
+  # or like this:
+  #
+  #   ['other', 'strings'].select(&fltr(upcase: /^S/)) # => ['strings']
+  #
+  # This approach has one gotcha:
+  #
+  #   # wrong
+  #   ['some', 'strings'].select(&fltr(class: String)) # => []
+  #
+  #   # right
+  #   ['some', 'strings'].select(&fltr(itself: String)) # => ['some', 'strings']
+  #
+  def filter(attrs)
     lambda do |o|
       hash.all?{|k, v| v === o.send(k)} # rubocop:disable Style/CaseEquality
     end
@@ -9,26 +72,85 @@ module ProcMe
 
   alias_method :fltr, :filter
 
-  def set(hash)
+  # Constructs block, able to set objects attribute values
+  #
+  # @param attrs [Hash] hash of !{attribute name => value}
+  # @return [Proc] block, accepting any object and returning it
+  #
+  # Use it like this:
+  #
+  #   some_array.each(&set(attr: value))
+  #
+  def set(attrs)
     lambda do |o|
-      hash.each{|k, v| o.send("#{k}=", v)}
+      attrs.each{|k, v| o.send("#{k}=", v)}
       o
     end
   end
 
-  def call(hash)
+  # Constructs block, able to call methods on object
+  #
+  # @param methods list of symbols or  !{method => args} pairs
+  # @return [Proc] block, accepting any object and returning results of
+  #   sending methods to it.
+  #
+  # Use it like this:
+  #
+  #   some_array.each(&call(:method, other_method: [args]))
+  #
+  # If you call only one method, block will return just a result of call
+  # for each object:
+  #
+  #   ['test', 'me'].map(&call(sub: ['e', '*'])) # => ['t*st', 'm*']
+  #
+  # If you call several methods, it would be array of results for each
+  # object:
+  #
+  #   ['test', 'me'].map(&call(sub: ['e', '*'], index: 'e'))
+  #   # => [['t*st', 2], ['m*', 2]]
+  #
+  # The latter example also shows that +#call+ sends each method to object
+  # itself, not the result of previous method call.
+  #
+  def call(*methods)
+    h = methods.last.is_a?(Hash) ? methods.pop : {}
+    hash = Hash[*methods.flat_map{|sym| [sym, []]}].merge(h)
+
     lambda do |o|
-      hash.each{|k, v| o.send(k, *v)}
-      o
+      ProcMe._singularize(hash.map{|k, v| o.send(k, *v)})
     end
   end
 
-  def get(*array)
+  # Constructs block, able to receive attribute values from object
+  #
+  # @param attrs list of symbols
+  # @return [Proc] block, accepting any object and returning its attr
+  #   values.
+  #
+  # Use it like this:
+  #
+  #   some_array.map(&get(:attr, :other))
+  #
+  # Extremely useful for sorting:
+  #
+  #   ['John', 'Alice', 'jane'].sort_by(&get(:length, :downcase)
+  #   # => ['jane', 'John', 'Alice']
+  #
+  # As with {#call}, `#get` returns array of results for several methods
+  # and one result for only one method (with is not very useful anyways,
+  # as `map(&get(:length))` is a full equivalent of `map(&:length)`).
+  #
+  def get(*attrs)
     lambda do |o|
-      array.map{|v| o.send(*v)}
+      ProcMe._singularize(attrs.map{|v| o.send(*v)})
     end
   end
 
   # now we can use both include ProcMe & no include approach
   extend self # rubocop:disable Style/ModuleFunction
+
+  # @private
+  def _singularize(arr)
+    arr.length == 1 ? arr.first : arr
+  end
 end

data/procme.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name     = 'procme'
-  s.version  = '0.0.1'
+  s.version  = '0.0.2'
   s.authors  = ['Victor Shepelev']
   s.email    = 'zverok.offline@gmail.com'
   s.homepage = 'https://github.com/zverok/procme'
@@ -25,5 +25,8 @@ Gem::Specification.new do |s|
   end
   s.require_paths = ["lib"]
 
+  s.has_rdoc = 'yard'
+
   s.add_development_dependency 'rubocop', '~> 0.30'
+  s.add_development_dependency 'rspec', '~> 3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: procme
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Victor Shepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-15 00:00:00.000000000 Z
+date: 2015-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -24,6 +24,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.30'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
 description: ! "    ProcMe provides you with methods for DRY and clean processing
   of\n    enumerables.\n"
 email: zverok.offline@gmail.com
@@ -31,6 +45,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .yardopts
+- LICENSE.txt
 - README.md
 - examples/example.rb
 - lib/procme.rb
@@ -60,3 +76,4 @@ signing_key:
 specification_version: 4
 summary: Useful DRY proc-s for Ruby
 test_files: []
+has_rdoc: yard