transproc 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47014d88c8dfcb44ab8eb1fd2b3ca43824e9ce12
-  data.tar.gz: 22c7d90980ecb0c92c978d38661d948929babaa8
+  metadata.gz: 191351a547ec40a988d4948a669c8a19a9d9e7b5
+  data.tar.gz: 6fa7367728d8b2738b0cb8385bb5f95711952530
 SHA512:
-  metadata.gz: 9f80c2970dfd31a3e8d275855a5b927b32d85725f2339f9839ae8946d839a775629d11d5cb9e99bfae6b7051b0dd78dedfbd81de7641a79555bf73462896961b
-  data.tar.gz: 32f0e59dca2b63c9224112d07efab3ff24d26da84a01bf624553b862df0c09350ac50e88d2ac5cc571d555d367d036524df2e11b5128de4764dba5ca84bad667
+  metadata.gz: fed4a175a284af002c5a7d960512f06fa315a4997c74cc2512edbe491b0309b0e66370c89a4a3ebf56f1910aec2791aa2cfbbcdb5407070654443208976ce32e
+  data.tar.gz: 9060a11216f66bf85cadf56a60503e3a21878358641a4680aa35624077ff181bb9946b0e6c6cf0ac6c9b83a17e9719dadbef9d1e3760fd46a770ae967d3d5a16

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+env:
+  - CODECLIMATE_REPO_TOKEN=aead71de2239048f830499462c54b57dfc646f1d56ad5dcbbc3469a6ebaf97ca
+script: "bundle exec rake spec"
+rvm:
+  - 2.0
+  - 2.1
+  - rbx-2
+  - jruby
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+## v0.1.0 to-be-released
+
+### Added
+
+* added bang-method equivalents to all functions (solnic)
+* group and wrap array transformations (solnic)
+* date, datetime and time coercions (solnic)
+* numeric coercions (solnic)
+* boolean coercions (solnic)
+* [hash] `:nest` which wraps a set of keys under a new key (solnic)
+
+[Compare v0.0.1...master](https://github.com/solnic/transproc/compare/v0.0.1...master)
+
+## v0.0.1 2014-12-24
+
+First public release \o/

data/README.md

@@ -1,8 +1,21 @@
+[gem]: https://rubygems.org/gems/transproc
+[travis]: https://travis-ci.org/solnic/transproc
+[gemnasium]: https://gemnasium.com/solnic/transproc
+[codeclimate]: https://codeclimate.com/github/solnic/transproc
+[coveralls]: https://coveralls.io/r/solnic/transproc
+[inchpages]: http://inch-ci.org/github/solnic/transproc
+
 # Transproc
 
-Experimental functional transformations for Ruby.
+[![Gem Version](https://badge.fury.io/rb/transproc.svg)][gem]
+[![Build Status](https://travis-ci.org/solnic/transproc.svg?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/solnic/transproc.png)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/solnic/transproc/badges/gpa.svg)][codeclimate]
+[![Test Coverage](https://codeclimate.com/github/solnic/transproc/badges/coverage.svg)][codeclimate]
+[![Inline docs](http://inch-ci.org/github/solnic/transproc.svg?branch=master)][inchpages]
 
-![I have no idea what I'm doing](http://thumbpress.com/wp-content/uploads/2013/05/I-Have-No-Idea-What-Im-Doing-1.jpg)
+Functional transformations for Ruby. It's currently used as one of the data
+mapping backends in [Ruby Object Mapper](http://rom-rb.org).
 
 ## Installation
 
@@ -23,19 +36,36 @@ Or install it yourself as:
 ## Usage
 
 ``` ruby
-require 'transproc/hash'
+require 'transproc/all'
 
 # compose transformation functions
-transformation = Transproc(:symbolize_keys) + Transproc(:map, user_name: :name))
+transformation = Transproc(:symbolize_keys) + Transproc(:map_hash, user_name: :name))
 
 # call the function
+transformation['user_name' => 'Jane']
+# => {:name=>"Jane"}
+
+# or using a helper (no, it's not a good idea to include it here :))
+include Transproc::Composer
+
+transformation = compose do |fns|
+  fns << t(:symbolize_keys) << t(:map_hash, user_name: :name)
+end
+
 transformation['user_name' => 'Jane']
 # => {:name=>"Jane"}
 ```
 
+## Credits
+
+This project is inspired by the work of following people:
+
+* [Markus Schirp](https://github.com/mbj) and [morpher](https://github.com/mbj/morpher) project
+* [Josep M. Bach](https://github.com/txus) and [kleisli](https://github.com/txus/kleisli) project
+
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/transproc/fork )
+1. Fork it ( https://github.com/solnic/transproc/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`)

data/Rakefile

@@ -1,2 +1,5 @@
-require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
+task default: :spec
+
+RSpec::Core::RakeTask.new(:spec)

data/lib/transproc.rb

@@ -1,4 +1,6 @@
-require "transproc/version"
+require 'transproc/version'
+require 'transproc/function'
+require 'transproc/composer'
 
 module Transproc
   def self.register(*args, &block)
@@ -13,25 +15,6 @@ module Transproc
   def self.[](name)
     functions.fetch(name)
   end
-
-  class Function
-    attr_reader :fn, :args
-
-    def initialize(fn, args = [])
-      @fn = fn
-      @args = args
-    end
-
-    def call(value)
-      fn[value, *args]
-    end
-    alias_method :[], :call
-
-    def compose(other)
-      self.class.new(-> value { other[fn[value]] })
-    end
-    alias_method :+, :compose
-  end
 end
 
 def Transproc(fn, *args)

data/lib/transproc/all.rb

@@ -0,0 +1,5 @@
+require 'transproc'
+
+require 'transproc/coercions'
+require 'transproc/array'
+require 'transproc/hash'

data/lib/transproc/array.rb

@@ -0,0 +1,28 @@
+module Transproc
+  register(:map_array) do |array, *fns|
+    Transproc(:map_array!, *fns)[array.dup]
+  end
+
+  register(:map_array!) do |array, *fns|
+    array.map! { |value| fns.reduce(:+)[value] }
+  end
+
+  register(:wrap) do |array, key, keys|
+    Transproc(:map_array, Transproc(:nest, key, keys))[array]
+  end
+
+  register(:group) do |array, key, keys|
+    names = nil
+
+    array
+      .group_by { |hash|
+        names ||= hash.keys - keys
+        Hash[names.zip(hash.values_at(*names))]
+      }
+      .map { |root, children|
+        children.map! { |child| Hash[keys.zip(child.values_at(*keys))] }
+        children.select! { |child| child.values.any? }
+        root.merge(key => children)
+      }
+  end
+end

data/lib/transproc/coercions.rb

@@ -1,6 +1,15 @@
 require 'date'
+require 'bigdecimal'
+require 'bigdecimal/util'
 
 module Transproc
+  TRUE_VALUES = [true, 1, '1', 'on', 't', 'true', 'y', 'yes'].freeze
+  FALSE_VALUES = [false, 0, '0', 'off', 'f', 'false', 'n', 'no'].freeze
+
+  BOOLEAN_MAP = Hash[
+    TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])
+  ].freeze
+
   register(:to_string) do |value|
     value.to_s
   end
@@ -13,7 +22,23 @@ module Transproc
     value.to_f
   end
 
+  register(:to_decimal) do |value|
+    value.to_d
+  end
+
+  register(:to_boolean) do |value|
+    BOOLEAN_MAP.fetch(value)
+  end
+
   register(:to_date) do |value|
     Date.parse(value)
   end
+
+  register(:to_time) do |value|
+    Time.parse(value)
+  end
+
+  register(:to_datetime) do |value|
+    DateTime.parse(value)
+  end
 end

data/lib/transproc/composer.rb

@@ -0,0 +1,33 @@
+module Transproc
+  module Composer
+
+    class Factory
+      attr_reader :fns, :default
+
+      def initialize(default = nil)
+        @fns = []
+        @default = default
+      end
+
+      def <<(other)
+        fns.concat(Array(other).compact)
+        self
+      end
+
+      def to_fn
+        fns.reduce(:+) || default
+      end
+    end
+
+    def t(*args)
+      Transproc(*args)
+    end
+
+    def compose(default = nil)
+      factory = Factory.new(default)
+      yield(factory)
+      factory.to_fn
+    end
+
+  end
+end

data/lib/transproc/function.rb

@@ -0,0 +1,20 @@
+module Transproc
+  class Function
+    attr_reader :fn, :args
+
+    def initialize(fn, args = [])
+      @fn = fn
+      @args = args
+    end
+
+    def call(value)
+      fn[value, *args]
+    end
+    alias_method :[], :call
+
+    def compose(other)
+      self.class.new(-> *result { other[fn[*result]] }, args)
+    end
+    alias_method :+, :compose
+  end
+end

data/lib/transproc/hash.rb

@@ -1,9 +1,37 @@
 module Transproc
   register(:symbolize_keys) do |hash|
-    Hash[hash.map { |k, v| [k.to_sym, v] }]
+    Transproc(:symbolize_keys!)[hash.dup]
   end
 
-  register(:map) do |hash, mapping|
-    Hash[hash.map { |k, v| [mapping[k], v] }]
+  register(:symbolize_keys!) do |hash|
+    hash.keys.each { |key| hash[key.to_sym] = hash.delete(key) }
+    hash
+  end
+
+  register(:map_hash) do |hash, mapping|
+    Transproc(:map_hash!, mapping)[hash.dup]
+  end
+
+  register(:map_hash!) do |hash, mapping|
+    mapping.each { |k, v| hash[v] = hash.delete(k) }
+    hash
+  end
+
+  register(:map_key) do |hash, key, fn|
+    hash.merge(key => fn[hash[key]])
+  end
+
+  register(:map_key!) do |hash, key, fn|
+    hash.update(key => fn[hash[key]])
+  end
+
+  register(:nest) do |hash, key, keys|
+    Transproc(:nest!, key, keys)[hash.dup]
+  end
+
+  register(:nest!) do |hash, root, keys|
+    child = Hash[keys.zip(keys.map { |key| hash.delete(key) })]
+
+    hash.update(root => child.values.any? ? child : nil)
   end
 end

data/lib/transproc/version.rb

@@ -1,3 +1,3 @@
 module Transproc
-  VERSION = "0.0.1"
+  VERSION = "0.1.0".freeze
 end

data/spec/integration/array_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe 'Array transformations with Transproc' do
+  describe 'map_array' do
+    it 'applies funtions to all values' do
+      map = Transproc(:map_array, Transproc(:symbolize_keys))
+
+      original = [
+        { 'name' => 'Jane', 'title' => 'One' },
+        { 'name' => 'Jane', 'title' => 'Two' }
+      ]
+
+      input = original
+
+      output = [
+        { name: 'Jane', title: 'One' },
+        { name: 'Jane', title: 'Two' }
+      ]
+
+      expect(map[input]).to eql(output)
+      expect(input).to eql(original)
+    end
+  end
+
+  describe 'map_array!' do
+    it 'updates array with the result of the function applied to each value' do
+      map = Transproc(:map_array!, Transproc(:symbolize_keys))
+
+      input = [
+        { 'name' => 'Jane', 'title' => 'One' },
+        { 'name' => 'Jane', 'title' => 'Two' }
+      ]
+
+      output = [
+        { name: 'Jane', title: 'One' },
+        { name: 'Jane', title: 'Two' }
+      ]
+
+      map[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
+  describe 'wrap' do
+    it 'returns a new array with wrapped hashes' do
+      wrap = Transproc(:wrap, :task, [:title])
+
+      input = [{ name: 'Jane', title: 'One' }]
+      output = [{ name: 'Jane', task: { title: 'One' } }]
+
+      expect(wrap[input]).to eql(output)
+    end
+
+    it 'returns a array new with deeply wrapped hashes' do
+      wrap =
+        Transproc(
+          :map_array,
+          Transproc(:nest, :user, [:name, :title]),
+          Transproc(:map_key, :user, Transproc(:nest, :task, [:title]))
+      )
+
+      input = [{ name: 'Jane', title: 'One' }]
+      output = [{ user: { name: 'Jane', task: { title: 'One' } } }]
+
+      expect(wrap[input]).to eql(output)
+    end
+  end
+
+  describe 'group' do
+    it 'returns a new array with grouped hashes' do
+      group = Transproc(:group, :tasks, [:title])
+
+      input = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
+      output = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
+
+      expect(group[input]).to eql(output)
+    end
+  end
+
+  describe 'composition' do
+    it 'allows composing transformations' do
+      map = Transproc(:map_array, Transproc(:symbolize_keys))
+      group = Transproc(:group, :tasks, [:title])
+
+      input = [
+        { 'name' => 'Jane', 'title' => 'One' },
+        { 'name' => 'Jane', 'title' => 'Two' }
+      ]
+
+      output = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
+
+      transformation = map + group
+
+      expect(transformation[input]).to eql(output)
+    end
+  end
+end

data/spec/integration/coercions_spec.rb

@@ -1,7 +1,5 @@
 require 'spec_helper'
 
-require 'transproc/coercions'
-
 describe 'Transproc / Coercions' do
   describe 'to_string' do
     it 'turns integer into a string' do
@@ -25,10 +23,54 @@ describe 'Transproc / Coercions' do
     end
   end
 
+  describe 'to_decimal' do
+    it 'turns string into a decimal' do
+      expect(Transproc(:to_decimal)['1.251']).to eql(BigDecimal('1.251'))
+    end
+
+    it 'turns float into a decimal' do
+      expect(Transproc(:to_decimal)[1.251]).to eql(BigDecimal('1.251'))
+    end
+
+    it 'turns integer into a decimal' do
+      expect(Transproc(:to_decimal)[1]).to eql(BigDecimal('1.0'))
+    end
+  end
+
   describe 'to_date' do
     it 'turns string into a date' do
       date = Date.new(1983, 11, 18)
       expect(Transproc(:to_date)['18th, November 1983']).to eql(date)
     end
   end
+
+  describe 'to_time' do
+    it 'turns string into a time object' do
+      time = Time.new(2012, 1, 23, 11, 7, 7)
+      expect(Transproc(:to_time)['2012-01-23 11:07:07']).to eql(time)
+    end
+  end
+
+  describe 'to_datetime' do
+    it 'turns string into a date' do
+      datetime = DateTime.new(2012, 1, 23, 11, 7, 7)
+      expect(Transproc(:to_datetime)['2012-01-23 11:07:07']).to eql(datetime)
+    end
+  end
+
+  describe 'to_boolean' do
+    subject(:coercer) { Transproc(:to_boolean) }
+
+    Transproc::TRUE_VALUES.each do |value|
+      it "turns #{value.inspect} to true" do
+        expect(coercer[value]).to be(true)
+      end
+    end
+
+    Transproc::FALSE_VALUES.each do |value|
+      it "turns #{value.inspect} to false" do
+        expect(coercer[value]).to be(false)
+      end
+    end
+  end
 end

data/spec/integration/composer_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Transproc::Composer do
+  subject(:object) do
+    Class.new do
+      include Transproc::Composer
+
+      def fn
+        compose do |fns|
+          fns << t(:map_array, t(:symbolize_keys)) <<
+            t(:map_array, t(:map_key, :age, t(:to_integer)))
+        end
+      end
+    end.new
+  end
+
+  it 'allows composing functions' do
+    expect(object.fn[[{ 'age' => '12' }]]).to eql([{ age: 12 }])
+  end
+end

data/spec/integration/hash_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe 'Hash mapping with Transproc' do
+  describe 'symbolize_keys' do
+    it 'returns a new hash with symbolized keys' do
+      symbolize_keys = Transproc(:symbolize_keys)
+
+      input = { 'foo' => 'bar' }
+      output = { foo: 'bar' }
+
+      expect(symbolize_keys[input]).to eql(output)
+      expect(input).to eql('foo' => 'bar')
+    end
+  end
+
+  describe 'symbolize_keys!' do
+    it 'returns updated hash with symbolized keys' do
+      symbolize_keys = Transproc(:symbolize_keys!)
+
+      input = { 'foo' => 'bar' }
+      output = { foo: 'bar' }
+
+      symbolize_keys[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
+  describe 'nest!' do
+    it 'returns new hash with keys nested under a new key' do
+      nest = Transproc(:nest!, :baz, ['foo'])
+
+      input = { 'foo' => 'bar' }
+      output = { baz: { 'foo' => 'bar' } }
+
+      nest[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
+  describe 'map_hash' do
+    it 'returns a new hash with applied functions' do
+      map = Transproc(:map_hash, 'foo' => :foo)
+
+      input = { 'foo' => 'bar', :bar => 'baz' }
+      output = { foo: 'bar', bar: 'baz' }
+
+      expect(map[input]).to eql(output)
+      expect(input).to eql('foo' => 'bar', :bar => 'baz')
+    end
+  end
+
+  describe 'map_hash!' do
+    it 'returns updated hash with applied functions' do
+      map = Transproc(:map_hash!, 'foo' => :foo)
+
+      input = { 'foo' => 'bar', :bar => 'baz' }
+      output = { foo: 'bar', bar: 'baz' }
+
+      map[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
+  describe 'map_key' do
+    it 'applies function to value under specified key' do
+      transformation = Transproc(:map_key, :user, Transproc(:symbolize_keys))
+
+      input = { user: { 'name' => 'Jane' } }
+      output = { user: { name: 'Jane' } }
+
+      expect(transformation[input]).to eql(output)
+      expect(input).to eql(user: { 'name' => 'Jane' })
+    end
+  end
+
+  describe 'map_key!' do
+    it 'applies function to value under specified key' do
+      transformation = Transproc(:map_key!, :user, Transproc(:symbolize_keys))
+
+      input = { user: { 'name' => 'Jane' } }
+      output = { user: { name: 'Jane' } }
+
+      transformation[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
+  describe 'nested transform' do
+    it 'applies functions to nested hashes' do
+      symbolize_keys = Transproc(:symbolize_keys)
+      map_user_key = Transproc(:map_key, :user, symbolize_keys)
+
+      transformation = symbolize_keys + map_user_key
+
+      input = { 'user' => { 'name' => 'Jane' } }
+      output = { user: { name: 'Jane' } }
+
+      expect(transformation[input]).to eql(output)
+    end
+  end
+
+  describe 'combining transformations' do
+    it 'applies functions to the hash' do
+      symbolize_keys = Transproc(:symbolize_keys)
+      map = Transproc(:map_hash, user_name: :name, user_email: :email)
+
+      transformation = symbolize_keys + map
+
+      input = { 'user_name' => 'Jade', 'user_email' => 'jade@doe.org' }
+      output = { name: 'Jade', email: 'jade@doe.org' }
+
+      result = transformation[input]
+
+      expect(result).to eql(output)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,92 +1,6 @@
-require 'transproc'
-
-#
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause this
-# file to always be loaded, without a need to explicitly require it in any files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
-  config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    # be_bigger_than(2).and_smaller_than(4).description
-    #   # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #   # => "be bigger than 2"
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
-    mocks.verify_partial_doubles = true
-  end
-
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-=begin
-  # These two settings work together to allow you to limit a spec run
-  # to individual examples or groups you care about by tagging them with
-  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
-  # get run.
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  # Limits the available syntax to the non-monkey patched syntax that is recommended.
-  # For more details, see:
-  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
-  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = 'doc'
-  end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-=end
+if RUBY_ENGINE == "rbx"
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
 end
+
+require 'transproc/all'

data/transproc.gemspec

@@ -5,7 +5,7 @@ require 'transproc/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "transproc"
-  spec.version       = Transproc::VERSION
+  spec.version       = Transproc::VERSION.dup
   spec.authors       = ["Piotr Solnica"]
   spec.email         = ["piotr.solnica@gmail.com"]
   spec.summary       = %q{Experimental functional transformations for Ruby}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: transproc
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-24 00:00:00.000000000 Z
+date: 2014-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,17 +61,25 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/transproc.rb
+- lib/transproc/all.rb
+- lib/transproc/array.rb
 - lib/transproc/coercions.rb
+- lib/transproc/composer.rb
+- lib/transproc/function.rb
 - lib/transproc/hash.rb
 - lib/transproc/version.rb
+- spec/integration/array_spec.rb
 - spec/integration/coercions_spec.rb
-- spec/integration/hash_mapping_spec.rb
+- spec/integration/composer_spec.rb
+- spec/integration/hash_spec.rb
 - spec/integration/transproc_spec.rb
 - spec/spec_helper.rb
 - transproc.gemspec
@@ -100,8 +108,10 @@ signing_key:
 specification_version: 4
 summary: Experimental functional transformations for Ruby
 test_files:
+- spec/integration/array_spec.rb
 - spec/integration/coercions_spec.rb
-- spec/integration/hash_mapping_spec.rb
+- spec/integration/composer_spec.rb
+- spec/integration/hash_spec.rb
 - spec/integration/transproc_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/spec/integration/hash_mapping_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-require 'transproc/hash'
-
-describe 'Hash mapping with Transproc' do
-  describe 'symbolize_keys' do
-    it 'returns a new hash with symbolized keys' do
-      symbolize_keys = Transproc(:symbolize_keys)
-
-      input = { 'foo' => 'bar' }
-      output = { foo: 'bar' }
-
-      expect(symbolize_keys[input]).to eql(output)
-    end
-  end
-
-  describe 'map' do
-    it 'returns a new hash with applied functions' do
-      map = Transproc(:map, 'foo' => :foo)
-
-      input = { 'foo' => 'bar' }
-      output = { foo: 'bar' }
-
-      expect(map[input]).to eql(output)
-    end
-  end
-
-  describe 'combining transformations' do
-    it 'applies functions to the hash' do
-      symbolize_keys = Transproc(:symbolize_keys)
-      map = Transproc(:map, user_name: :name, user_email: :email)
-
-      transformation = symbolize_keys + map
-
-      input = { 'user_name' => 'Jade', 'user_email' => 'jade@doe.org' }
-      output = { name: 'Jade', email: 'jade@doe.org' }
-
-      result = transformation[input]
-
-      expect(result).to eql(output)
-    end
-  end
-end