better_struct 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 !binary "U0hBMQ==":
-  metadata.gz: 7bd4c7340e753f2f1a1a45cfa3645974ba42e904
-  data.tar.gz: 7e5dfdc186cd437b4f7ecb3817347620f9d41180
+  metadata.gz: 97a1b4ed42f6ff0493a116d85f4126719ef77483
+  data.tar.gz: f074b953c21dbc3f369980fda77cba90a97d4f9c
 SHA512:
-  metadata.gz: b5f82d591147bc6982821210e2739dec1b627545bce0d8c2646b42b5fe7ad85149cfad7ae1d40ea7d11ef8b408fc8305f79bead4a8868a7cf0962874f4ebd5b7
-  data.tar.gz: 5de5763b76b662d79a3a38970a37962d8af2db38d4614fd6a53735f9846465298e2c470718bab23449caa712bcfee3995cf20ab21484963a24f2cd8d478b0dcf
+  metadata.gz: 47f5073d2d96c0dafa123fd270fc134f7e5cb8c4db66ed6cd8b87ef54052f5f8213198f515f3b0816f390f60257e9d51790137c2e4d0d47f222826354dbf4ef2
+  data.tar.gz: e40dfdbb67e4f26060550cd009da3e9e079e102fbeabeeb2fadeb3ab5bb18e17ea364c65f84ca9a6bb80b5b9699530930ab7a0653f1cbdbe6b5c556461892fa6

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.2.1
+install: "bundle install"
+script: "ruby -Ilib:test test/better_struct_test.rb"

data/README.md

@@ -1,14 +1,29 @@
 # BetterStruct
 
-Use your data without pain.
-It behaves like OpenStruct with monads. Look at the examples below.
+[![Build Status](https://travis-ci.org/exAspArk/better_struct.svg)](https://travis-ci.org/exAspArk/better_struct)
+
+**BetterStruct** is a data structure which allows you to use your data without pain.
+
+It behaves like an OpenStruct on steroids with monad.
+
+```ruby
+hash = { "FooBar1" => { foo_bar2: "Hello World!" } }
+
+# Instead of this:
+if hash["FooBar1"] && hash["FooBar1"][:foo_bar2]
+  puts hash["FooBar1"][:foo_bar2]
+end
+
+# Simply use:
+puts BetterStruct.new(hash).foo_bar1.foo_bar2.value
+```
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'better_struct'
+gem "better_struct"
 ```
 
 And then execute:
@@ -68,9 +83,28 @@ better_struct.gsub("foo", "super-").value == "super-foo" # => true
 
     $ ruby -Ilib:test test/better_struct_test.rb
 
+## Benchmarking
+
+It is as fast as an OpenStruct:
+
+```
+$ ruby scripts/benchmark.rb
+
+Calculating -------------------------------------
+          OpenStruct     6.562k i/100ms
+        BetterStruct     7.155k i/100ms
+-------------------------------------------------
+          OpenStruct     75.194k (± 7.4%) i/s -    374.034k
+        BetterStruct     76.987k (± 6.7%) i/s -    386.370k
+
+Comparison:
+        BetterStruct:    76986.7 i/s
+          OpenStruct:    75193.6 i/s - 1.02x slower
+```
+
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/better_struct/fork )
+1. Fork it ( https://github.com/exAspArk/better_struct/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/better_struct.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/exAspArk/better_struct"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
+  spec.files         = `git ls-files | grep -v script`.split("\n")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
@@ -24,4 +24,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.5"
   spec.add_development_dependency "pry-byebug", "~> 2.0"
+  spec.add_development_dependency "benchmark-ips", "~> 2.1"
+  spec.add_development_dependency "stackprof"
 end

data/lib/better_struct.rb

@@ -1,20 +1,15 @@
 require "better_struct/version"
-require "forwardable"
 require "active_support/inflector"
 
 class BetterStruct
-  extend Forwardable
+  PARAMETERIZE_SEPARATOR = "_".freeze
+  EQUAL_SIGN = "=".freeze
+  MAP_METHOD_NAMES = %i(map map!).to_set.freeze
 
   attr_reader :value
-  def_delegator :value, :to_s
 
-  def initialize(value)
+  def initialize(value = nil)
     @value = value
-    @defined_methods = {}
-
-    if value && value.respond_to?(:each_pair)
-      value.each_pair { |key, value| @defined_methods[methodize(key.to_s)] = value }
-    end
   end
 
   def ==(other)
@@ -22,49 +17,80 @@ class BetterStruct
   end
 
   def inspect
-    "#{ self.class }<#{ @value.inspect }>"
+    "#{ self.class }<#{ value.inspect }>"
+  end
+
+  def to_s
+    value.to_s
   end
 
 private
 
   def methodize(string)
-    ActiveSupport::Inflector.parameterize(ActiveSupport::Inflector.underscore(string), "_")
+    result = ActiveSupport::Inflector.underscore(string)
+
+    if result =~ /[^\w]/
+      ActiveSupport::Inflector.parameterize(result, PARAMETERIZE_SEPARATOR)
+    else
+      result
+    end
   end
 
   def wrap(value)
     value.is_a?(self.class) ? self : self.class.new(value)
   end
 
-  def wrap_block_arguments(*args, &block)
+  def wrap_block_args(*args, &block)
     return if block.nil?
 
     Proc.new do |*args|
-      wrapped_arguments = args.map { |arg| wrap(arg) }
+      wrapped_arguments = args.map! { |arg| wrap(arg) }
       block.call(*wrapped_arguments)
     end
   end
 
-  def method_missing(*args, &block)
-    method_name = args.first.to_s
-
+  def method_missing(method_name, *args, &block)
     if value.respond_to?(method_name)
-      result = wrap(value.public_send(*args, &wrap_block_arguments(*args, &block)))
-
-      method_name == "map" ? unwrap_items(result) : result
+      delegate_method(method_name, *args, &block)
+    elsif assignment?(method_name, *args, &block) && defined_methods
+      attribute = methodize(method_name[0...-1])
+      @defined_methods[attribute] = args.first
     else
-      wrap(@defined_methods[method_name])
+      wrap(defined_methods[method_name.to_s])
     end
   end
 
-  def unwrap_items(wrapped_array)
-    array = wrapped_array.value
+  def assignment?(method_name, *args, &block)
+    method_name[-1] == EQUAL_SIGN && args.size == 1 && block.nil?
+  end
 
-    if array
-      array_with_unwrapped_items = array.map { |i| i.is_a?(self.class) ? i.value : i }
+  def defined_methods
+    @defined_methods ||= begin
+      result = {}
+
+      if value && value.respond_to?(:each_pair)
+        value.each_pair { |key, value| result[methodize(key.to_s)] = value }
+      end
+
+      result
+    end
+  end
+
+  def delegate_method(method_name, *args, &block)
+    result = wrap(value.public_send(method_name, *unwrap_items(args), &wrap_block_args(*args, &block)))
+
+    if MAP_METHOD_NAMES.include?(method_name)
+      wrap(unwrap_items(result.value))
+    else
+      result
+    end
+  end
 
-      wrap(array_with_unwrapped_items)
+  def unwrap_items(items)
+    if items.is_a?(Array)
+      items.map! { |item| item.is_a?(self.class) ? item.value : item }
     else
-      wrap(nil)
+      items
     end
   end
 end

data/lib/better_struct/version.rb

@@ -1,3 +1,3 @@
 class BetterStruct
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/test/better_struct_test.rb

@@ -2,69 +2,98 @@ require "better_struct"
 require "minitest/autorun"
 require "pry"
 
-class BetterStructTest < Minitest::Test
-  def test_maybe_monad
-    better_struct = BetterStruct.new(nil)
+module BetterStructTest
+  class MaybeMonad < Minitest::Test
+    def test_maybe_monad
+      better_struct = BetterStruct.new(nil)
 
-    assert_equal better_struct.some_method, better_struct
+      assert better_struct.some_method == better_struct
+    end
   end
 
-  def test_result_wrapping
-    assert_equal BetterStruct.new("foobar")[0..2], BetterStruct.new("foo")
-  end
+  class Wrapping < Minitest::Test
+    def test_wrapping
+      assert BetterStruct.new("foobar")[0..2] == BetterStruct.new("foo")
+    end
 
-  def test_getting_value
-    better_struct = BetterStruct.new("foobar")
+    def test_equality
+      assert BetterStruct.new(1) == BetterStruct.new(1.0)
+      refute BetterStruct.new(1) == 1
+    end
 
-    assert_equal better_struct.value, "foobar"
-  end
+    def test_getting_value
+      better_struct = BetterStruct.new("foobar")
 
-  def test_unwrapped_to_s_method
-    better_struct = BetterStruct.new(1)
+      assert better_struct.value == "foobar"
+    end
 
-    assert_equal better_struct.to_s, "1"
-  end
+    def test_unwrapped_to_s_method
+      better_struct = BetterStruct.new(1)
 
-  def test_block_argument_wrapping
-    better_struct = BetterStruct.new([3, 2, 1])
+      assert better_struct.to_s == "1"
+    end
+
+    def test_block_argument_wrapping
+      better_struct = BetterStruct.new([3, 2, 1])
 
-    better_struct.each_with_index do |val, i|
-      assert val.is_a?(BetterStruct)
-      assert val.value.is_a?(Integer)
-      assert i.is_a?(BetterStruct)
-      assert i.value.is_a?(Integer)
+      better_struct.each_with_index do |val, i|
+        assert val.is_a?(BetterStruct)
+        assert val.value.is_a?(Integer)
+        assert i.is_a?(BetterStruct)
+        assert i.value.is_a?(Integer)
+      end
     end
   end
 
-  def test_hash_methods
-    better_struct = BetterStruct.new({ "FooBar1" => { foo_bar2: "Hello World!" } })
+  class LikeOpenStruct < Minitest::Test
+    def test_hash_methods
+      better_struct = BetterStruct.new({ "FooBar1" => { foo_bar2: "Hello World!" } })
 
-    assert_equal better_struct.foo_bar1.foo_bar2, BetterStruct.new("Hello World!")
-  end
+      assert better_struct.foo_bar1.foo_bar2 == BetterStruct.new("Hello World!")
+    end
 
-  def test_map_result
-    better_struct = BetterStruct.new([1, 2, 3])
+    def test_map_result_unwrapping
+      better_struct = BetterStruct.new([1, 2, 3])
 
-    mapped = better_struct.map do |i|
-      assert i.is_a?(BetterStruct)
-      i
+      mapped = better_struct.map { |i| i }
+
+      mapped.value.each { |i| refute i.is_a?(BetterStruct) }
     end
 
-    mapped.value.each do |i|
-      assert !i.is_a?(BetterStruct)
+    def test_operators
+      better_struct = BetterStruct.new([1, 2, 3])
+
+      assert better_struct.map { |i| i * i }.value == [1, 4, 9]
     end
-  end
 
-  def test_equality
-    assert BetterStruct.new(1) == BetterStruct.new(1.0)
-    assert BetterStruct.new(1) != 1
-  end
+    def test_underscoring_methods
+      better_struct = BetterStruct.new({ "Word (With-Space)" => 1 })
 
-  def test_underscoring_methods
-    assert BetterStruct.new({ "Word (With-Space)" => 1 }).word_with_space.value == 1
-  end
+      assert better_struct.word_with_space.value == 1
+    end
+
+    def test_transliteration
+      better_struct = BetterStruct.new({ "Título" => 1 })
+
+      assert better_struct.titulo.value == 1
+    end
+
+    def test_new_assignment
+      better_struct = BetterStruct.new
 
-  def test_transliteration
-    assert BetterStruct.new({ "Título" => 1 }).titulo.value == 1
+      better_struct.head = [1, 2, 3]
+
+      assert better_struct.head == BetterStruct.new([1, 2, 3])
+    end
+
+    def test_input_args_immutability
+      better_struct = BetterStruct.new(head: [1, 2, 3])
+      tail = [4, 5, 6]
+
+      better_struct.head.concat(tail)
+
+      assert better_struct.head == BetterStruct.new([1, 2, 3, 4, 5, 6])
+      assert tail == [4, 5, 6]
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: better_struct
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Evgeny Li
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-26 00:00:00.000000000 Z
+date: 2015-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -80,6 +80,34 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Use your data without pain
 email:
 - exaspark@gmail.com
@@ -87,6 +115,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md