scash 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d4027b8c16c80e55adc1684995a68ae3845e37b
-  data.tar.gz: dba5b4f126fe90764752c77fe622460c8c06d93e
+  metadata.gz: f18dc252c49e5b61bf36756f3094ea165a24143a
+  data.tar.gz: 92cb2148378adfb9a5eb3346c474f8c74feb0f4d
 SHA512:
-  metadata.gz: 53430248c797466b5e5de7d09a44c84c7b92ce231560b9d332658e423cf30d8d1424dac3f18c30b3ace8459fbbef48721b0171aef488ba7e4335fca721458d8a
-  data.tar.gz: 8d47354d191d0ef4d67d7f403b64e41a2041d21c019d05a54af95dd3da1033d02e50c1281be16fa303234b84620962da573f6a0bd50579e0f28f60286f3bbe3a
+  metadata.gz: c39f698028d8efc8151e5d885c09a007d1680bcb9bdd40b8f604ec427e9b713643a2568d79727dd86be8fcd20c1f4bfbe2b97c004ca76a44f4e9dca56c47c071
+  data.tar.gz: 61f207aa4f27ea24a197211ed38ec26759338ba0604cd2f70e582ee01db129017a55b5b42081fe9adf22f5ce4b2aefb16bee808cbd065a23529c4bc2eb056833

data/lib/scash.rb

@@ -12,31 +12,26 @@ class Scash
 
   def initialize(variables = nil, klass = HashWithIndifferentAccess)
     @klass = klass
-    @stack = variables ? [convert(variables)] : []
-    @hashes = variables ? [build_hash] : []
-    @inverse_hashes = variables ? [build_inverse_hash] : []
+    @stack = [global_variables, convert(variables)].compact
+    build!
   end
 
   def to_hash
-    any? ? @hashes.first.merge(global_variables) : global_variables
+    @hashes.first
   end
 
   def to_inverse_hash
-    any? ? @inverse_hashes.first.merge(global_variables) : global_variables
+    @inverse_hashes.first
   end
 
   def scope(variables)
     @stack.unshift convert(variables)
     added = true
-    @hashes.unshift build_hash
-    @inverse_hashes.unshift build_inverse_hash
+    build!
     yield
   ensure
-    @stack.shift
-    if added
-      @hashes.shift
-      @inverse_hashes.shift
-    end
+    @stack.shift if added
+    build!
   end
   alias :with :scope
 
@@ -54,6 +49,7 @@ class Scash
 
   def define_global_variables(variables)
     global_variables.merge! convert(variables)
+    build!
   end
 
   private
@@ -83,8 +79,20 @@ class Scash
   end
 
   def convert(variables)
+    return if variables.nil?
+
     raise(ArgumentError, "Variables should respond to `keys`") unless variables.respond_to?("keys")
-    @klass.new(variables)
+    variables.is_a?(@klass) ? variables : @klass.new(variables)
+  end
+
+  def build!
+    @hashes = stack.size.times.map do |index|
+      build_hash(index)
+    end
+
+    @inverse_hashes = stack.size.times.map do |index|
+      build_inverse_hash(index)
+    end
   end
 
 end

data/lib/scash/version.rb

@@ -1,3 +1,3 @@
 class Scash
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/test/test_scash.rb

@@ -1,184 +1,179 @@
 require 'helper'
 
-class TestScash < Minitest::Test
-  describe "basics" do
-    it "should be instantiable" do
-      assert scash = Scash.new
-    end
+describe Scash do
+  it "is instantiable" do
+    assert Scash.new
+  end
 
-    it "should be scopable" do
-      scash = Scash.new
+  it "is scopable" do
+    scash = Scash.new
 
-      assert_equal %w(), scash.keys
-      scash.with({:a => 1}) do
-        assert_equal 1, scash[:a]
+    assert_equal %w(), scash.keys
+    scash.with({:a => 1}) do
+      assert_equal 1, scash[:a]
+      assert_equal 1, scash[:a, true]
+      assert_equal 1, scash['a', true]
+      assert_equal %w(a), scash.keys
+
+      scash.with({"a" => 2}) do
+        assert_equal 2, scash[:a]
         assert_equal 1, scash[:a, true]
         assert_equal 1, scash['a', true]
         assert_equal %w(a), scash.keys
 
-        scash.with({"a" => 2}) do
-          assert_equal 2, scash[:a]
-          assert_equal 1, scash[:a, true]
-          assert_equal 1, scash['a', true]
-          assert_equal %w(a), scash.keys
+        scash.with({"b" => 3}) do
+          assert_equal 3, scash[:b]
+          assert_equal 3, scash[:b, true]
+          assert_equal 3, scash[:b, true]
 
-          scash.with({"b" => 3}) do
-            assert_equal 3, scash[:b]
+          scash.with({"b" => 4}) do
+            assert_equal 4, scash[:b]
             assert_equal 3, scash[:b, true]
             assert_equal 3, scash[:b, true]
-
-            scash.with({"b" => 4}) do
-              assert_equal 4, scash[:b]
-              assert_equal 3, scash[:b, true]
-              assert_equal 3, scash[:b, true]
-            end
           end
         end
+      end
 
-        scash.with({"b" => 3}) do
-          assert_equal 1, scash[:a]
-          assert_equal %w(a b), scash.keys
-          assert_equal 3, scash["b"]
-          assert_equal 1, scash[:a, true]
-          assert_equal 1, scash['a', true]
-          assert_equal 3, scash[:b, true]
-          assert_equal 3, scash['b', true]
-        end
-
+      scash.with({"b" => 3}) do
         assert_equal 1, scash[:a]
-        assert_equal %w(a), scash.keys
+        assert_equal %w(a b), scash.keys
+        assert_equal 3, scash["b"]
+        assert_equal 1, scash[:a, true]
+        assert_equal 1, scash['a', true]
+        assert_equal 3, scash[:b, true]
+        assert_equal 3, scash['b', true]
       end
-      assert_equal %w(), scash.keys
+
+      assert_equal 1, scash[:a]
+      assert_equal %w(a), scash.keys
     end
+    assert_equal %w(), scash.keys
+  end
 
-    it "should keep scope instact when an error occurs" do
-      scash = Scash.new
-      assert_raises(ArgumentError) do
-        scash.with(["a" => 1]) do
-        end
+  it "keeps scope instact when an error occurs" do
+    scash = Scash.new
+    assert_raises(ArgumentError) do
+      scash.with(["a" => 1]) do
       end
-
-      assert_equal({}, scash.to_hash)
     end
 
-    it "should accept variables in initializer" do
-      scash = Scash.new({:a => 1})
-      assert_equal 1, scash[:a]
-      assert_equal({"a" => 1}, scash.to_hash)
-      scash.with({:b => 2}) do
-        assert_equal 1, scash[:a]
-        assert_equal 2, scash[:b]
-        scash.define_global_variables :c => 3
-      end
+    assert_equal({}, scash.to_hash)
+  end
+
+  it "accepts variables in initializer" do
+    scash = Scash.new({:a => 1})
+    assert_equal 1, scash[:a]
+    assert_equal({"a" => 1}, scash.to_hash)
+    scash.with({:b => 2}) do
       assert_equal 1, scash[:a]
-      assert_equal 3, scash[:c]
+      assert_equal 2, scash[:b]
+      scash.define_global_variables :c => 3
     end
+    assert_equal 1, scash[:a]
+    assert_equal 3, scash[:c]
+  end
 
-    it "should typecast correctly" do
-      scash = Scash.new({:a => 1})
-      assert_equal({"a" => 1}, scash.to_hash)
-      assert_equal HashWithIndifferentAccess, scash.to_hash.class
+  it "typecasts correctly" do
+    scash = Scash.new({:a => 1})
+    assert_equal({"a" => 1}, scash.to_hash)
+    assert_equal HashWithIndifferentAccess, scash.to_hash.class
 
-      scash = Scash.new({:a => 1})
-      assert_equal({"a" => 1}, scash.to_inverse_hash)
-      assert_equal HashWithIndifferentAccess, scash.to_inverse_hash.class
+    scash = Scash.new({:a => 1})
+    assert_equal({"a" => 1}, scash.to_inverse_hash)
+    assert_equal HashWithIndifferentAccess, scash.to_inverse_hash.class
 
-      class SubHash < HashWithIndifferentAccess
-      end
+    class SubHash < HashWithIndifferentAccess
+    end
 
-      scash = Scash.new({:a => 1}, SubHash)
-      assert_equal({"a" => 1}, scash.to_hash)
-      assert_equal SubHash, scash.to_hash.class
+    scash = Scash.new({:a => 1}, SubHash)
+    assert_equal({"a" => 1}, scash.to_hash)
+    assert_equal SubHash, scash.to_hash.class
 
-      scash = Scash.new({:a => 1}, SubHash)
-      assert_equal({"a" => 1}, scash.to_inverse_hash)
-      assert_equal SubHash, scash.to_inverse_hash.class
-    end
+    scash = Scash.new({:a => 1}, SubHash)
+    assert_equal({"a" => 1}, scash.to_inverse_hash)
+    assert_equal SubHash, scash.to_inverse_hash.class
+  end
 
-    it "should reuse instances" do
-      class Foo
-        attr_accessor :bar
-      end
+  it "reuses instances" do
+    class Foo
+      attr_accessor :bar
+    end
 
-      foo1 = Foo.new
-      foo2 = Foo.new
-      foo1id = foo1.object_id
-      foo2id = foo2.object_id
+    foo1 = Foo.new
+    foo2 = Foo.new
+    foo1id = foo1.object_id
+    foo2id = foo2.object_id
 
-      scash = Scash.new
-      scash.with({"a" => foo1}) do
-        assert_equal foo1id, scash["a"].object_id
-        scash["a"].bar = "bar1"
-        scash.with({"b" => foo2}) do
-          assert_equal "bar1", scash["a"].bar
-          assert_equal foo1id, scash["a"].object_id
-          assert_equal foo2id, scash["b"].object_id
-          scash["b"].bar = "bar2"
-        end
-        assert_equal foo1id, scash["a"].object_id
+    scash = Scash.new
+    scash.with({"a" => foo1}) do
+      assert_equal foo1id, scash["a"].object_id
+      scash["a"].bar = "bar1"
+      scash.with({"b" => foo2}) do
         assert_equal "bar1", scash["a"].bar
-        assert_equal "bar2", foo2.bar
+        assert_equal foo1id, scash["a"].object_id
+        assert_equal foo2id, scash["b"].object_id
+        scash["b"].bar = "bar2"
       end
-
-      assert_equal "bar1", foo1.bar
+      assert_equal foo1id, scash["a"].object_id
+      assert_equal "bar1", scash["a"].bar
       assert_equal "bar2", foo2.bar
     end
-  end
 
-  describe "global variables" do
-    it "should be able to define a global variable" do
-      scash = Scash.new
-      scash.with({:a => 1}) do
-        scash.define_global_variables :result => 1337
-        assert_equal 1, scash[:a]
-        assert_equal 1337, scash[:result]
+    assert_equal "bar1", foo1.bar
+    assert_equal "bar2", foo2.bar
+  end
+end
 
-        scash.with({:b => 2}) do
-          assert_equal 1, scash[:a]
-          assert_equal 2, scash[:b]
-          assert_equal 1337, scash[:result]
-        end
+describe "global variables" do
+  it "is able to define a global variable" do
+    scash = Scash.new
+    scash.with({:a => 1}) do
+      scash.define_global_variables :result => 1337
+      assert_equal 1, scash[:a]
+      assert_equal 1337, scash[:result]
 
+      scash.with({:b => 2}) do
         assert_equal 1, scash[:a]
-        assert_nil scash[:b]
+        assert_equal 2, scash[:b]
         assert_equal 1337, scash[:result]
       end
 
-      assert_nil scash[:a]
+      assert_equal 1, scash[:a]
       assert_nil scash[:b]
       assert_equal 1337, scash[:result]
     end
 
-    it "should overwrite a global variable with same name" do
-      scash = Scash.new
-      scash.with({:a => 1}) do
-        scash.define_global_variables :result => 1337
-        assert_equal 1337, scash[:result]
+    assert_nil scash[:a]
+    assert_nil scash[:b]
+    assert_equal 1337, scash[:result]
+  end
 
-        scash.with({:b => 2}) do
-          assert_equal 1337, scash[:result]
-          assert_equal 2, scash[:b]
-          scash.define_global_variables :result => "foo"
-          scash.define_global_variables :b => "bar"
-          assert_equal "bar", scash[:b]
-          assert_equal "foo", scash[:result]
-        end
+  it "overwrites a global variable with same name" do
+    scash = Scash.new
+    scash.with({:a => 1}) do
+      scash.define_global_variables :result => 1337
+      assert_equal 1337, scash[:result]
 
+      scash.with({:b => 2}) do
+        assert_equal 1337, scash[:result]
+        assert_equal 2, scash[:b]
+        scash.define_global_variables :result => "foo"
+        scash.define_global_variables :b => "bar"
+        assert_equal 2, scash[:b]
         assert_equal "foo", scash[:result]
       end
 
       assert_equal "foo", scash[:result]
-      assert_equal "bar", scash[:b]
     end
+
+    assert_equal "foo", scash[:result]
+    assert_equal "bar", scash[:b]
   end
 
-  describe "behave like a hash" do
-    it "should respond to merge" do
-      scash = Scash.new
-      scash.with({:a => 1}) do
-        assert_equal({:a => 1, :b => 2}.with_indifferent_access, scash.merge(:b => 2))
-      end
+  it "responds to merge" do
+    scash = Scash.new
+    scash.with({:a => 1}) do
+      assert_equal({:a => 1, :b => 2}.with_indifferent_access, scash.merge(:b => 2))
     end
   end
-
-end
+end

metadata

@@ -1,83 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: scash
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Stephan Kaag
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-13 00:00:00.000000000 Z
+date: 2014-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   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'
 - !ruby/object:Gem::Dependency
   name: coveralls
   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: A scoped hash
@@ -87,8 +87,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .ruby-version
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -107,17 +106,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A scoped hash

data/.ruby-version

@@ -1 +0,0 @@
-2.0.0-p247