sexp2ruby 0.0.1

data/lib/sexp2ruby/version.rb

@@ -0,0 +1,3 @@
+module Sexp2Ruby
+  VERSION = "0.0.1"
+end

data/lib/sexp2ruby.rb

@@ -0,0 +1,4 @@
+require "sexp2ruby/version"
+require "sexp2ruby/errors"
+require "sexp2ruby/core_extensions/regexp"
+require "sexp2ruby/processor"

data/sexp2ruby.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sexp2ruby/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sexp2ruby"
+  spec.version       = Sexp2Ruby::VERSION
+  spec.authors       = ['Ryan Davis', 'Jared Beck']
+  spec.email         = ['jared@jaredbeck.com']
+  spec.summary       = 'Generates ruby from RubyParser S-expressions'
+  spec.description   = <<-EOS
+Generates ruby from RubyParser-compatible S-expressions.
+It is a fork of ruby2ruby with slightly different goals.
+  EOS
+  spec.homepage      = 'https://github.com/jaredbeck/sexp2ruby'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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']
+
+  spec.required_ruby_version = ">= 1.9.3"
+
+  spec.add_runtime_dependency "sexp_processor", "~> 4.6"
+
+  spec.add_development_dependency "rspec-core", "~> 3.2"
+  spec.add_development_dependency "rspec-expectations", "~> 3.2"
+  spec.add_development_dependency "rspec-mocks", "~> 3.2"
+  spec.add_development_dependency "ruby_parser", "~> 3.7"
+end

data/spec/lib/processor_spec.rb

@@ -0,0 +1,183 @@
+require 'ruby_parser'
+
+module Sexp2Ruby
+  RSpec.describe Processor do
+    let(:processor) { described_class.new }
+    let(:processor_hash19) { described_class.new(hash_syntax: :ruby19) }
+
+    describe "#new" do
+      it "accepts hash_syntax option" do
+        expect(processor_hash19.hash_syntax).to eq(:ruby19)
+      end
+
+      context "unknown option" do
+        it "raises error" do
+          expect {
+            described_class.new(foo: "bar")
+          }.to raise_error(InvalidOption)
+        end
+      end
+
+      context "bad option value" do
+        it "raises error" do
+          expect {
+            described_class.new(hash_syntax: "banana")
+          }.to raise_error(InvalidOption)
+        end
+      end
+    end
+
+    describe "#extract_option" do
+      context "valid value" do
+        it "returns value" do
+          expect(
+            processor.extract_option([:a, :b], :b, :c)
+          ).to eq(:b)
+        end
+      end
+
+      context "nil value" do
+        it "returns default value" do
+          expect(
+            processor.extract_option([:a, :b], nil, :c)
+          ).to eq(:c)
+        end
+      end
+
+      context "invalid value" do
+        it "raises error" do
+          expect {
+            processor.extract_option([:a, :b], :d, :c)
+          }.to raise_error(InvalidOption)
+        end
+      end
+    end
+
+    describe "#process" do
+      context "hash" do
+        it "ruby19_one_pair" do
+          inp = s(:hash, s(:lit, :foo), s(:str, "bar"))
+          compare(inp, '{ foo: "bar" }', processor_hash19)
+        end
+
+        it "ruby19_when_key_has_special_chars" do
+          inp = s(:hash, s(:str, "hurr:durr"), s(:str, "bar"))
+          compare(inp, '{ "hurr:durr" => "bar" }', processor_hash19)
+        end
+
+        it "ruby19_when_key_is_not_a_literal" do
+          inp = s(:hash, s(:call, nil, :foo, s(:str, "bar")), s(:str, "baz"))
+          compare(inp, '{ foo("bar") => "baz" }', processor_hash19)
+        end
+
+        it "ruby19_mixed_pairs" do
+          inp = s(:hash, s(:lit, :foo), s(:str, "bar"), s(:lit, 0.7), s(:str, "baz"))
+          compare(inp, '{ foo: "bar", 0.7 => "baz" }', processor_hash19)
+        end
+
+        describe "parentheses" do
+          it "does not wrap string in parens" do
+            inp = s(:hash, s(:lit, :k), s(:str, "banana"))
+            out = '{ :k => "banana" }'
+            compare(inp, out, processor)
+          end
+
+          it "does not wrap number in parens" do
+            inp = s(:hash, s(:lit, :k), s(:lit, 0.07))
+            out = "{ :k => 0.07 }"
+            compare(inp, out, processor)
+          end
+
+          it "does not wrap boolean in parens" do
+            inp = s(:hash, s(:lit, :k), s(:true))
+            out = "{ :k => true }"
+            compare(inp, out, processor)
+          end
+
+          it "does not wrap nil in parens" do
+            inp = s(:hash, s(:lit, :k), s(:nil))
+            out = "{ :k => nil }"
+            compare(inp, out, processor)
+          end
+
+          it "does not wrap local variable (lvar) in parens" do
+            inp = s(:hash, s(:lit, :k), s(:lvar, :x))
+            out = "{ :k => x }"
+            compare(inp, out, processor, false)
+          end
+
+          it "does not wrap call in parens" do
+            inp = s(:hash, s(:lit, :k), s(:call, nil, :foo, s(:lit, :bar)))
+            out = "{ :k => foo(:bar) }"
+            compare(inp, out, processor)
+          end
+
+          it "wraps method call with block (iter) in parens" do
+            iter = s(:iter, s(:call, nil, :foo), s(:args), s(:str, "bar"))
+            inp = s(:hash, s(:lit, :k), iter)
+            out = '{ :k => (foo { "bar" }) }'
+            compare(inp, out, processor, false)
+          end
+        end
+      end
+    end
+
+    describe "#ruby19_hash_key?" do
+      context "symbol" do
+        it "returns true" do
+          expect(processor.ruby19_hash_key?(s(:lit, :foo))).to eq(true)
+        end
+      end
+
+      context "not a symbol" do
+        it "returns false" do
+          expect(processor.ruby19_hash_key?(s(:str, "foo"))).to eq(false)
+          expect(processor.ruby19_hash_key?(s(:lit, 7))).to eq(false)
+          expect(processor.ruby19_hash_key?(s(:true))).to eq(false)
+        end
+      end
+    end
+
+    describe "#util_dthing" do
+      let(:interpolation) {
+        s('a"b',
+          s(:evstr, s(:call, s(:lit, 1), :+, s(:lit, 1))),
+          s(:str, 'c"d/e')
+        )
+      }
+
+      context "dregx" do
+        it "generates regex with interpolation" do
+          out = '/a"b#{(1 + 1)}c"d\/e/'
+          expect(out).to eval_to(/a"b2c"d\/e/)
+          expect(processor.util_dthing(:dregx, interpolation)).to eq(out[1..-2])
+        end
+
+        it "generates regex with interpolation" do
+          interpolation = s('[\/\"]', s(:evstr, s(:lit, 42)))
+          out = '/[\/\"]#{42}/'
+          expect(out).to eval_to(/[\/\"]42/)
+          expect(processor.util_dthing(:dregx, interpolation)).to eq(out[1..-2])
+        end
+      end
+
+      context "dstr" do
+        it "generates string with interpolation" do
+          out = '"a\"b#{(1 + 1)}c\"d/e"'
+          expect(out).to eval_to('a"b2c"d/e')
+          expect(processor.util_dthing(:dstr, interpolation)).to eq(out[1..-2])
+        end
+      end
+    end
+
+    def compare(sexp, expected_ruby, processor, check_sexp = true, expected_eval = nil)
+      if check_sexp
+        expect(RubyParser.new.process(expected_ruby)).to eq(sexp)
+      end
+      expect(processor.process(sexp)).to eq(expected_ruby)
+      if expected_eval
+        expect(eval(expected_ruby)).to eq(expected_eval)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require "sexp2ruby"
+
+RSpec::Matchers.define :eval_to do |expected|
+  match do |actual|
+    eval(actual) == expected
+  end
+  failure_message do |actual|
+    "expected #{actual} to evaluate to #{expected}"
+  end
+end