scrawl 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fae72114f1a7396cc0e541f34ab73c3e005af43
-  data.tar.gz: edf0916f009bd56ec5a8225aaf086d8de5326b93
+  metadata.gz: 9a512d0f4fbdc135ac1abd41c6ecd4178c06acf2
+  data.tar.gz: f7bee93b9ea82ca2bd2411ac5077132a239601ae
 SHA512:
-  metadata.gz: ae0b61376227d10149e3f7fef6289344748c06293202ed03028672b24248ce925bfeee6186f1fb0b5747b77888bd2b29c2ee9aaca8956789bdb350768349ce11
-  data.tar.gz: 03e82b8abc0c119748b305f448f9bb2ecda76419afa2696d28b0d638325c028773396c1b5b411d015078fe87bc003bc0d96f95d06a9a56f307b08a446862ed6b
+  metadata.gz: 1513eabf269f6d398661d52bf65c48697bab3fc518fd8d649e8fc92a9f6d2e7c8d41f5aa46cd8aec6f684c5cd018597b4b730b56f0e8c4ce361f3a27107cc87f
+  data.tar.gz: c0882a43a7725eb851b235e868861d3766e850c6cfb7e50b2ffe1752454960bfb13d1e67fa9d3ef776eb63c87a3a2815007e57e98f79a011dc1bff0f5d4c1950

data/lib/scrawl.rb

@@ -1,11 +1,10 @@
 class Scrawl
+  include Enumerable
+
   KEY_VALUE_DELIMITER = "="
   PAIR_DELIMITER = " "
   NAMESPACE_DELIMITER = "."
-
-  require_relative "scrawl/version"
-
-  attr_reader :tree
+  DEFAULT_SPLAT_CHARACTER="*"
 
   def initialize(*trees)
     @tree = trees.inject({}) { |global, tree| global.merge(tree) }
@@ -16,22 +15,25 @@ class Scrawl
   end
 
   def inspect(namespace = nil)
-    @tree.map do |key, value|
+    tree.map do |key, value|
       case
-      when value.kind_of?(Hash) && value.none?
-        label(namespace, key) + KEY_VALUE_DELIMITER + element(nil)
-      when value.respond_to?(:to_hash)
-        Scrawl.new(value).inspect(key)
-      else
-        label(namespace, key) + KEY_VALUE_DELIMITER + element(value)
+        when value.nil? then nil
+        when value.respond_to?(:none?) && value.none? then nil
+        when value.respond_to?(:push) then itemize(namespace, key, value)
+        when value.respond_to?(:merge) then Scrawl.new(value).inspect(key)
+        else label(namespace, key) + KEY_VALUE_DELIMITER + element(value)
       end
-    end.join(PAIR_DELIMITER)
+    end.flatten.compact.join(PAIR_DELIMITER)
   end
 
   def to_s(namespace = nil)
     inspect(namespace)
   end
 
+  def each(&block)
+    tree.each(&block)
+  end
+
   def to_hash
     tree.to_hash
   end
@@ -51,4 +53,16 @@ class Scrawl
       else value.inspect
     end
   end
+
+  private def tree
+    @tree
+  end
+
+  private def itemize(namespace, key, list)
+    list.map do |item|
+      label(namespace, label(key, DEFAULT_SPLAT_CHARACTER)) + KEY_VALUE_DELIMITER + element(item)
+    end
+  end
+
+  require_relative "scrawl/version"
 end

data/lib/scrawl/version.rb

@@ -1,3 +1,3 @@
 class Scrawl
-  VERSION = "2.1.0"
+  VERSION = "3.0.0"
 end

data/spec/lib/scrawl_spec.rb

@@ -1,189 +1,267 @@
 require "spec_helper"
 
 RSpec.describe Scrawl do
-  let(:input) { { a: 1 } }
-  let(:trees) { [input] }
-  let(:scrawl) { described_class.new(*trees) }
-  let(:internal_tree) { scrawl.instance_variable_get(:@tree) }
+  let(:inputs) { [input] }
+  let(:scrawl) { described_class.new(*inputs) }
 
-  describe ".new" do
-    context "with single" do
-      shared_examples "setup single" do
-        it "sets internal tree to that hash" do
-          expect(internal_tree).to eq(input)
-        end
-      end
+  shared_context "for single input" do
+    let(:input) do
+      { "a" => "a" }
+    end
 
-      context "hash object" do
-        include_examples "setup single"
-      end
+    let(:output) do
+      'a="a"'
+    end
+  end
 
-      context "scrawl object" do
-        let(:tree) { Scrawl.new(*trees) }
+  shared_context "for multiple input" do
+    let(:input) do
+      { "a" => "a", "b" => "b" }
+    end
 
-        include_examples "setup single"
-      end
+    let(:output) do
+      'a="a" b="b"'
     end
+  end
 
-    context "with multiple" do
-      let(:merged_input) { { a: 1, b: 2 } }
+  shared_examples "for output" do
+    it "joins the key value together with an ="  do
+      expect(function).to eq(output)
+    end
+  end
 
-      shared_examples "setup all" do
-        it "merges all arguments into a single tree" do
-          expect(internal_tree).to eq(merged_input)
+  describe "#inspect" do
+    let(:namespace) do
+      nil
+    end
+    let(:function) do
+      scrawl.inspect(namespace)
+    end
+
+    context "with single input" do
+      context "with a namespace" do
+        include_context "for single input"
+
+        let(:namespace) do
+          "a"
+        end
+        let(:output) do
+          'a.a="a"'
         end
-      end
 
-      context "hashes objects" do
-        let(:trees) { [{ a: 1 }, { b: 2 }] }
+        it "combines the namespace keys" do
+          expect(function).to eq(output)
+        end
       end
 
-      context "scrawl objects" do
-        let(:trees) { [Scrawl.new(a: 1), Scrawl.new(b: 2)] }
+      context "that is a string" do
+        let(:input) do
+          { "a" => "a" }
+        end
+        let(:output) do
+          'a="a"'
+        end
+
+        include_examples "for output"
       end
-    end
-  end
 
-  describe "#merge" do
-    let(:merge) { scrawl.merge(compared) }
+      context "that is a nil" do
+        let(:input) do
+          { "a" => nil }
+        end
+        let(:output) do
+          ''
+        end
 
-    shared_examples "merges" do
-      it "combines with the internal tree" do
-        expect(merge).to eq(a: 1, b: 2)
+        include_examples "for output"
       end
-    end
 
-    context "with hash" do
-      let(:compared) { { b: 2 } }
+      context "that is a numeric" do
+        let(:input) do
+          { "a" => 1 }
+        end
+        let(:output) do
+          'a=1'
+        end
 
-      include_examples "merges"
-    end
+        include_examples "for output"
+      end
 
-    context "with scrawl object" do
-      let(:compared) { Scrawl.new(b: 2) }
+      context "that is a lambda" do
+        let(:input) do
+          { "a" => -> { "a" + "a" } }
+        end
+        let(:output) do
+          'a="aa"'
+        end
 
-      include_examples "merges"
-    end
-  end
+        include_examples "for output"
+      end
 
-  describe "#inspect" do
-    let(:stream) { "a=1" }
-    let(:namespace) { nil }
-    let(:inspect) { scrawl.inspect(namespace) }
+      context "that is an empty hash" do
+        let(:input) do
+          { "a" => {} }
+        end
+        let(:output) do
+          ''
+        end
 
-    context "with a single pair" do
-      it "joins the key value together with an ="  do
-        expect(inspect).to eq(stream)
+        include_examples "for output"
       end
 
-      context "and text value" do
-        let(:input) { { a: "example" } }
-
-        it "includes the escaped text" do
-          expect(inspect).to eq("a=\"example\"")
+      context "that is a hash" do
+        let(:input) do
+          { "a" => { "a" => "a" } }
+        end
+        let(:output) do
+          'a.a="a"'
         end
-      end
 
-      context "and a proc value" do
-        let(:input) { { a: -> { "example#{1 + 1}" } } }
+        include_examples "for output"
+      end
 
-        it "evaluate the proc" do
-          expect(inspect).to eq("a=\"example2\"")
+      context "that is a empty array" do
+        let(:input) do
+          { "a" => [] }
+        end
+        let(:output) do
+          ''
         end
 
-        context "with a random portion" do
-          let(:input) { { a: -> { "example#{rand(1..100000)}" } } }
+        include_examples "for output"
+      end
 
-          it "never stores the value" do
-            first = scrawl.inspect
-            second = scrawl.inspect
-            expect(first).to_not eq(second)
-          end
+      context "that is a array" do
+        let(:input) do
+          { "a" => ["b", "c"] }
+        end
+        let(:output) do
+          'a.*="b" a.*="c"'
         end
+
+        include_examples "for output"
       end
 
-      context "and a number value" do
-        it "returns just the number" do
-          expect(inspect).to eq("a=1")
+      context "that is a scrawl" do
+        let(:input) do
+          { "a" => Scrawl.new({ "a" => "a" }) }
+        end
+        let(:output) do
+          'a.a="a"'
         end
-      end
 
-      context "and a symbol value" do
-        let(:input) { { a: :example } }
+        include_examples "for output"
+      end
+    end
 
-        it "returns the escaped string equivelent" do
-          expect(inspect).to eq("a=\"example\"")
+    context "with multiple input" do
+      context "that are strings" do
+        let(:input) do
+          { "a" => "a", "b" => "b" }
+        end
+        let(:output) do
+          'a="a" b="b"'
         end
-      end
 
-      context "and a regexp value" do
-        let(:input) { { a: /foo(.+)/ } }
+        include_examples "for output"
+      end
 
-        it "returns the escaped regexp" do
-          expect(inspect).to eq("a=/foo(.+)/")
+      context "that are nils" do
+        let(:input) do
+          { "a" => nil, "b" => nil }
+        end
+        let(:output) do
+          ''
         end
+
+        include_examples "for output"
       end
 
-      context "and a hash" do
-        let(:input) { { a: Hash.new } }
+      context "that are numerics" do
+        let(:input) do
+          { "a" => 1, "b" => 2 }
+        end
+        let(:output) do
+          'a=1 b=2'
+        end
+
+        include_examples "for output"
+      end
 
-        it "returns as if nil" do
-          expect(inspect).to eq("a=nil")
+      context "that are lambdas" do
+        let(:input) do
+          { "a" => -> { "a" + "a" }, "b" => -> { "b" + "b" } }
         end
+        let(:output) do
+          'a="aa" b="bb"'
+        end
+
+        include_examples "for output"
       end
-    end
 
-    context "with multiple pairs" do
-      let(:input) { { a: 1, b: 2 } }
-      let(:stream) { "a=1 b=2" }
+      context "that are empty hashs" do
+        let(:input) do
+          { "a" => {}, "b" => {} }
+        end
+        let(:output) do
+          ''
+        end
 
-      it "delimits key value pairs with space" do
-        expect(inspect).to eq(stream)
+        include_examples "for output"
       end
-    end
 
-    context "with a given namespace" do
-      let(:namespace) { "b" }
-      let(:stream) { "b.a=1" }
+      context "that are hashs" do
+        let(:input) do
+          { "a" => { "a" => "a" }, "b" => { "b" => "b" } }
+        end
+        let(:output) do
+          'a.a="a" b.b="b"'
+        end
 
-      it "prefixes the namespace to the key" do
-        expect(inspect).to eq(stream)
+        include_examples "for output"
       end
-    end
 
-    context "with nested hash tree" do
-      let(:input) { { a: { b: 1, c: 2 } } }
-      let(:stream) { "a.b=1 a.c=2" }
+      context "that are empty arrays" do
+        let(:input) do
+          { "a" => [], "b" => [] }
+        end
+        let(:output) do
+          ''
+        end
 
-      it "namespaces the nested pairs" do
-        expect(inspect).to eq(stream)
+        include_examples "for output"
       end
-    end
-  end
 
-  describe "#tree" do
-    let(:tree) { scrawl.tree }
+      context "that are arrays" do
+        let(:input) do
+          { "a" => ["b", "c"], "b" => ["e", "f"] }
+        end
+        let(:output) do
+          'a.*="b" a.*="c" b.*="e" b.*="f"'
+        end
 
-    it "returns the internal tree" do
-      expect(tree).to eq(internal_tree)
-    end
-  end
+        include_examples "for output"
+      end
 
-  describe "#to_h" do
-    let(:to_h) { scrawl.to_h }
+      context "that are scrawls" do
+        let(:input) do
+          { "a" => Scrawl.new({ "a" => "a" }), "b" => Scrawl.new({ "b" => "b" }) }
+        end
+        let(:output) do
+          'a.a="a" b.b="b"'
+        end
 
-    it "returns the internal tree" do
-      expect(to_h).to eq(internal_tree)
+        include_examples "for output"
+      end
     end
   end
 
-  describe "#to_hash" do
-    let(:to_hash) { scrawl.to_hash }
-
-    it "returns the internal tree" do
-      expect(to_hash).to eq(internal_tree)
+  describe "#to_s" do
+    include_context "for single input"
+    it "uses inspect with no namespace" do
+      expect(scrawl).to receive(:inspect).with(nil)
+      scrawl.to_s
     end
   end
 
-  describe "#=="
 end

metadata

@@ -1,127 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: scrawl
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Kurtis Rainbolt-Greene
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-31 00:00:00.000000000 Z
+date: 2015-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.10.5
+        version: '1.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.10.5
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.4.2
+        version: '10.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.4.2
+        version: '10.4'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.1
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.1
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: pry-doc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.7
+        version: '0.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.7
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: '2.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: ruby-prof
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.8
+        version: '0.15'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.15.8
+        version: '0.15'
 description: Turn hashes into simple log-ready output
 email:
 - me@kurtisrainboltgreene.name