kappamaki 0.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 10ed7a3b93d835a5c218b8ef5580105f2f9fbe66
-  data.tar.gz: 5999f91ecf1e906886a602191f10e59d8604cf76
+SHA256:
+  metadata.gz: f70299e68a03ca40f132bb49a60f2fa3795118ca12a39e79d018957e434febcc
+  data.tar.gz: b462b40eec165b8a2cc909c9c7a4b8dc75a3e4abfde52204e1ccbc0479de4b5e
 SHA512:
-  metadata.gz: 6c80afb2dc07f5aded681535d1f355682517016a6a0730f9a9bc79401cc3a7283a6135d55db7ea9c1b545df2c30b8fcda01f248ee315da7b73146bb3f347c1bf
-  data.tar.gz: 4174272fab1d6528bf87efb8fd970d309a5f893ed8f7b4a5b289b60164dfe305edad6ef3ef78975b4a83fe32b3080bc67880b8420e3e91a3f7299d559bcfb969
+  metadata.gz: 273a3d2b356ec902cd30238d2b53da839d982124c9157056507cfbf5ed4a0efdfa2807e65d760bcf9c55eaccd5dccd3e6d2bf79a9b62f957ab9f635b2c6b3190
+  data.tar.gz: 46cdaf4f025c4ea8e00d73b3df5c359865ab2fe9aef960a01869c75f26f3e5613460d802bd56e1ebf3fb5167436d42db98b01ded1d098991a6cc033b4777054f

data/.github/workflows/ruby.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ["3.4"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dprint/check@v2.2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - run: bundle exec rake
+      - run: bundle exec rake fix
+      - run: git diff HEAD --exit-code --color
+      - uses: coverallsapp/github-action@v2

data/.rubocop.yml

@@ -0,0 +1,16 @@
+AllCops:
+  NewCops: enable
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  Include:
+    - "**/Rakefile"
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 100
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/SymbolArray:
+  EnforcedStyle: brackets

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+## 1.1.0 (2025-11-04)
+
+- Update minimum Ruby version to 3.2
+- The `symbolize_keys` function is now more generic
+- Verifies argument types (#25)
+
+## 1.0.0 (2015-12-22)
+
+- Stable release
+
+## 0.0.3 (2014-09-26)
+
+- added the `symbolize_keys_deep!` method
+
+## 0.0.2 (2014-09-23)
+
+- Require at least Ruby 1.9.3
+
+## 0.0.1 (2014-09-23)
+
+- Basic functionality for deep symbolizing hash keys

data/DEVELOPMENT.md

@@ -0,0 +1,13 @@
+# Development handbook
+
+- run all tests: `bundle exec rake`
+- auto-fix all fixable issues: `bundle exec fix`
+- update dependencies: `bundle update`
+
+## Release a new version to RubyGems
+
+- in a branch:
+  - update CHANGELOG.md
+  - search and replace all occurrences of `1.1.0`
+  - ship this branch
+- push a new version to Rubygems: `rake release`

data/Gemfile

@@ -1,4 +1,10 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in kappamaki.gemspec
 gemspec
+
+gem "bundler"
+gem "rake"
+gem "rspec"
+gem "rubocop"
+gem "simplecov"

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Originate
+Copyright (c) 2014 Kevin Goslar
 
 MIT License
 

data/README.md

@@ -1,17 +1,11 @@
-# Kappamaki <a href="https://travis-ci.org/Originate/kappamaki" alt="Build Status" target="_blank"><img src="https://travis-ci.org/Originate/kappamaki.svg?branch=master"></a>
+[![CI](https://github.com/kevgo/kappamaki/actions/workflows/ruby.yml/badge.svg)](https://github.com/kevgo/kappamaki/actions/workflows/ruby.yml)
+[![Coverage Status](https://coveralls.io/repos/github/kevgo/kappamaki/badge.svg?branch=main)](https://coveralls.io/github/kevgo/kappamaki?branch=main)
 
-_Tools for natural, high-level, sophisticated Cucumber steps._
+Inspired by the simplicity of a cucumber-filled sushi roll, Kappamaki provides
+helper methods to implement Cucumber steps that define data using natural
+language.
 
-The name comes from the sushi roll filled with pieces of cucumber,
-which adds naturalness and freshness to a meal.
-
-
-## Usage
-
-Kappamaki provides a number of helper methods that can be used directly
-in your Cucumber step definitions.
-
-### from_sentence
+## from_sentence
 
 Parses a list of values from a sentence.
 
@@ -19,26 +13,25 @@ Parses a list of values from a sentence.
 Given the restaurant offers cucumber rolls, philadelphia rolls, and avocado rolls
 ```
 
-Your step definition would look like this:
+Your implementation of this Cucumber step would look like this:
 
 ```ruby
 Given /^the restaurant offers (.+)$/ do |menu_list|
 
   # menu_list is this string:
-  'cucumber rolls, philadelphia rolls, and avocado rolls'
+  # "cucumber rolls, philadelphia rolls, and avocado rolls"
 
-  # Let's parse this into an array
+  # let's parse this string into an array
   menu = Kappamaki.from_sentence menu_list
 
-  # The result, menu, is this array:
-  ['cucumber rolls', 'philadelphia rolls', 'avocado rolls']
+  # the result (the variable menu) is this array:
+  # ["cucumber rolls", "philadelphia rolls", "avocado rolls"]
 
   # Now we can set up our menu here...
 end
 ```
 
-
-### attributes_from_sentence
+## attributes_from_sentence
 
 Parses key-value pairs from natural sentences.
 
@@ -52,22 +45,23 @@ Your step definition would look like this:
 When /^I order a dinner with (.+)$/ do |order_items|
 
   # order_items is this string:
-  'starter: "miso soup" and entree: "cucumber rolls"'
+  # 'starter: "miso soup" and entree: "cucumber rolls"'
 
-  # Let's parse that string using Kappamaki
-  order_data = Kappamaki.attributes_from_sentence(order_items)
+  # Let's parse this string using Kappamaki
+  order_data = Kappamaki.attributes_from_sentence order_items
 
   # The result, order_data, is this hash:
-  { starter: "miso soup",
-    entree: "cucumber rolls" }
+  # {
+  #   starter: "miso soup",
+  #   entree: "cucumber rolls"
+  # }
 
   # now we can set up our order...
   create :order, order_data
 end
 ```
 
-
-### symbolize_keys_deep
+## symbolize_keys_deep
 
 Converts the keys of a hash into symbols.
 
@@ -81,17 +75,17 @@ Then I am served these items
 Your step definition would look like this:
 
 ```ruby
-Then ^I am served these items do |entrees|
+Then /^I am served these items$/ do |entrees|
   entrees.hashes.each do |entree|
 
     # entree is this hash:
-    { 'name' => 'miso soup', 'count' => '1' }
+    # { "name" => "miso soup", "count" => "1" }
 
     # Let's convert the keys to symbols.
     Kappamaki.symbolize_keys_deep! entree
 
     # Now entree is this hash:
-    { name: 'miso soup', count: '1' }
+    # { name: "miso soup", count: "1" }
 
     # Now we can use this hash in places that expect hashes with symbols
     expect(order).to include entree
@@ -99,18 +93,8 @@ Then ^I am served these items do |entrees|
 end
 ```
 
-
 ## Installation
 
-* add `gem 'kappamaki'` to your application's Gemfile
-* run `bundle install`
-* add `require 'kappamaki'` to your `/features/support/env.rb` file
-
-
-## Contributing
-
-1. Fork it ( https://github.com/Originate/kappamaki/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`)
-5. Create a new Pull Request
+- add `gem "kappamaki"` to your application's Gemfile
+- run `bundle install`
+- add `require 'kappamaki'` to your `/features/support/env.rb` file

data/Rakefile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bundler"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new :spec
+
+task default: [:lint, :spec]
+
+desc "Fix all auto-fixable issues"
+task "fix" do
+  sh "bundle exec rubocop -A"
+  sh "dprint fmt"
+end
+
+desc "Run linter"
+task "lint" do
+  sh "bundle exec rubocop"
+  sh "dprint check"
+end

data/dprint.json

@@ -0,0 +1,11 @@
+{
+  "markdown": {
+    "textWrap": "always"
+  },
+  "yaml": { },
+  "excludes": ["vendor"],
+  "plugins": [
+    "https://plugins.dprint.dev/markdown-0.18.0.wasm",
+    "https://plugins.dprint.dev/g-plane/pretty_yaml-v0.5.0.wasm"
+  ]
+}

data/kappamaki.gemspec

@@ -1,27 +1,23 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-Gem::Specification.new do |spec|
-  spec.name     = 'kappamaki'
-  spec.version  = '0.0.3'
-  spec.authors  = ['Kevin Goslar']
-  spec.email    = ['kevin.goslar@originate.com']
-  spec.summary  = 'Tools for natural, high-level, sophisticated Cucumber steps'
-  spec.homepage = 'https://github.com/Originate/kappamaki'
-  spec.license  = 'MIT'
-  spec.description = <<-EOF
+Gem::Specification.new do |gem|
+  gem.name     = "kappamaki"
+  gem.version  = "1.1.0"
+  gem.authors  = ["Kevin Goslar"]
+  gem.email    = ["kevin.goslar@gmail.com"]
+  gem.summary  = "Tools for defining data using natural language in Cucumber steps"
+  gem.homepage = "https://github.com/kevgo/kappamaki"
+  gem.license  = "MIT"
+  gem.description = <<-DESC
     Kappamaki is a collection of string manipulation methods
-    that make parsing high-lever cucumber steps easier.
-  EOF
+    that make parsing high-level cucumber steps easier.
+  DESC
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = []
-  spec.test_files    = spec.files.grep('spec')
-  spec.require_paths = ['lib']
+  gem.files         = `git ls-files -z`.split("\x0")
+  gem.executables   = []
+  gem.require_paths = ["lib"]
 
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rspec'
-
-  spec.required_ruby_version = '>= 1.9.3'
+  gem.required_ruby_version = ">= 3.2"
+  gem.metadata["rubygems_mfa_required"] = "true"
 end

data/lib/kappamaki.rb

@@ -1,34 +1,57 @@
+# Kappamaki provides helper methods to implement Cucumber steps
+# that define data using natural language.
 module Kappamaki
-
   # Parses a given string containing key-value pairs into a Hash
   #
   # Values must be delimited by double-quotes, like this:
   # key: "value"
-  def self.attributes_from_sentence sentence
-    attributes = Kappamaki.from_sentence(sentence)
-                          .map{|piece| piece.split ': '}
-                          .map{|key, value| [key.to_sym, value]}
-                          .flatten
-    Hash[*attributes]
+  #
+  # @param sentence [String] the sentence to parse
+  # @return [Hash] the parsed key-value pairs
+  # @raise [ArgumentError] if sentence is not a String
+  def self.attributes_from_sentence(sentence)
+    raise ArgumentError, "sentence must be a String" unless sentence.is_a?(String)
+
+    Kappamaki.from_sentence(sentence)
+             .map { |piece| piece.split(": ") }
+             .to_h { |key, value| [key.to_sym, value] }
   end
 
+  # Reverse of ActiveSupport's "to_sentence" method
+  #
+  # @param sentence [String] the sentence to parse
+  # @return [Array<String>] the parsed array of items
+  # @raise [ArgumentError] if sentence is not a String
+  def self.from_sentence(sentence)
+    raise ArgumentError, "sentence must be a String" unless sentence.is_a?(String)
 
-  # Reverse of Rails' to_sentence method
-  def self.from_sentence sentence
-    sentence.gsub(', and ', ', ')
-            .gsub(' and ', ', ')
-            .split(', ')
-            .map{|s| s.gsub '"', ''}
+    sentence.gsub(", and ", ", ")
+            .gsub(" and ", ", ")
+            .split(", ")
+            .map { |s| s.delete('"') }
   end
 
-
   # Converts all keys in the given hash to symbols
-  def self.symbolize_keys_deep!(h)
-    h.keys.each do |k|
-      ks    = k.to_sym
-      h[ks] = h.delete k
-      symbolize_keys_deep! h[ks] if h[ks].kind_of? Hash
+  #
+  # @param hash [Hash] the hash to modify
+  # @return [Hash] the modified hash with symbolized keys
+  # @raise [ArgumentError] if hash is not a Hash
+  def self.symbolize_keys_deep!(hash)
+    raise ArgumentError, "hash must be a Hash" unless hash.is_a?(Hash)
+
+    hash.keys.each do |key|
+      key_sym = key.to_sym
+      value = hash.delete(key)
+      hash[key_sym] = case value
+                      when Hash
+                        symbolize_keys_deep!(value)
+                      when Array
+                        value.map { |item| item.is_a?(Hash) ? symbolize_keys_deep!(item) : item }
+                      else
+                        value
+                      end
     end
-  end
 
+    hash
+  end
 end

data/spec/kappamaki_spec.rb

@@ -1,55 +1,96 @@
-require 'spec_helper'
-require 'kappamaki'
-
+require "spec_helper"
+require "kappamaki"
 
 describe Kappamaki do
+  describe ".attributes_from_sentence" do
+    test_data = {
+      'name: "Foo"' => { name: "Foo" },
+      'name: "Foo" and body: "Bar"' => { name: "Foo", body: "Bar" },
+      'name: "Foo", body: "Bar" and title: "Baz"' => { name: "Foo", body: "Bar", title: "Baz" },
+      'name: "Foo", body: "Bar", and title: "Baz"' => { name: "Foo", body: "Bar", title: "Baz" }
+    }
+    test_data.each do |sentence, expected_result|
+      it "parses '#{sentence}' into '#{expected_result}'" do
+        expect(Kappamaki.attributes_from_sentence(sentence)).to eql expected_result
+      end
+    end
+
+    it "raises ArgumentError when given non-string input" do
+      expect { Kappamaki.attributes_from_sentence(nil) }.to raise_error(ArgumentError, "sentence must be a String")
+      expect { Kappamaki.attributes_from_sentence(123) }.to raise_error(ArgumentError, "sentence must be a String")
+    end
+  end
 
-  test_data = {
-
-    attributes_from_sentence: {
-      'name: "Foo"'                                => {name: "Foo"},
-      'name: "Foo" and body: "Bar"'                => {name: 'Foo', body: 'Bar'},
-      'name: "Foo", body: "Bar" and title: "Baz"'  => {name: 'Foo', body: 'Bar', title: "Baz"},
-      'name: "Foo", body: "Bar", and title: "Baz"' => {name: 'Foo', body: 'Bar', title: "Baz"}
-    },
-
-    from_sentence: {
-      'one'                              => ['one'],
-      '"one"'                            => ['one'],
-      'one and two'                      => ['one', 'two'],
-      '"one" and "two"'                  => ['one', 'two'],
-      'one, two and three'               => ['one', 'two', 'three'],
-      '"one", "two" and "three"'         => ['one', 'two', 'three'],
-      'one, two, and three'              => ['one', 'two', 'three'],
-      'one, two, three and four'         => ['one', 'two', 'three', 'four'],
-      '"one", "two", "three" and "four"' => ['one', 'two', 'three', 'four']
+  describe ".from_sentence" do
+    test_data = {
+      "one" => ["one"],
+      '"one"' => ["one"],
+      "one and two" => %w[one two],
+      '"one" and "two"' => %w[one two],
+      "one, two and three" => %w[one two three],
+      '"one", "two" and "three"' => %w[one two three],
+      "one, two, and three" => %w[one two three],
+      "one, two, three and four" => %w[one two three four],
+      '"one", "two", "three" and "four"' => %w[one two three four]
     }
-  }
-
-  test_data.each do |method_name, expected|
-    describe method_name do
-      expected.each do |sentence, expected_result|
-        it "parses '#{sentence}' into '#{expected_result}'" do
-          expect(Kappamaki.send method_name, sentence).to eql expected_result
-        end
+    test_data.each do |sentence, expected_result|
+      it "parses '#{sentence}' into '#{expected_result}'" do
+        expect(Kappamaki.from_sentence(sentence)).to eql expected_result
       end
     end
+
+    it "handles empty string" do
+      expect(Kappamaki.from_sentence("")).to eq []
+    end
+
+    it "raises ArgumentError when given non-string input" do
+      expect { Kappamaki.from_sentence(nil) }.to raise_error(ArgumentError, "sentence must be a String")
+      expect { Kappamaki.from_sentence([]) }.to raise_error(ArgumentError, "sentence must be a String")
+    end
   end
 
+  describe ".symbolize_keys_deep!" do
+    it "converts string keys to symbols" do
+      actual = { "one" => "two", "alpha" => "beta" }
+      Kappamaki.symbolize_keys_deep!(actual)
+      expect(actual).to eq one: "two", alpha: "beta"
+    end
+
+    it "converts nested keys" do
+      actual = { "one" => { "alpha" => "beta" } }
+      Kappamaki.symbolize_keys_deep!(actual)
+      expect(actual).to eq one: { alpha: "beta" }
+    end
+
+    it "handles arrays containing hashes" do
+      actual = { "items" => [{ "name" => "foo" }, { "name" => "bar" }] }
+      Kappamaki.symbolize_keys_deep!(actual)
+      expect(actual).to eq items: [{ name: "foo" }, { name: "bar" }]
+    end
 
-  describe 'symbolize_keys_deep!' do
+    it "handles arrays containing non-hash values" do
+      actual = { "items" => ["foo", "bar", 123] }
+      Kappamaki.symbolize_keys_deep!(actual)
+      expect(actual).to eq items: ["foo", "bar", 123]
+    end
 
-    it 'converts string keys to symbols' do
-      actual = { 'one' => 'two', 'alpha' => 'beta' }
-      Kappamaki.symbolize_keys_deep! actual
-      expect(actual).to eq({ one: 'two', alpha: 'beta' })
+    it "handles empty hash" do
+      actual = {}
+      result = Kappamaki.symbolize_keys_deep!(actual)
+      expect(result).to eq({})
+      expect(actual).to eq({})
     end
 
-    it 'converts nested keys' do
-      actual = { 'one' => { 'alpha' => 'beta' }}
-      Kappamaki.symbolize_keys_deep! actual
-      expect(actual).to eq({ one: { alpha: 'beta' }})
+    it "returns the modified hash" do
+      actual = { "one" => "two" }
+      result = Kappamaki.symbolize_keys_deep!(actual)
+      expect(result).to eq one: "two"
+      expect(result).to be(actual)
+    end
+
+    it "raises ArgumentError when given non-hash input" do
+      expect { Kappamaki.symbolize_keys_deep!(nil) }.to raise_error(ArgumentError, "hash must be a Hash")
+      expect { Kappamaki.symbolize_keys_deep!("string") }.to raise_error(ArgumentError, "hash must be a Hash")
     end
   end
 end
-

data/spec/spec_helper.rb

@@ -1,9 +1,14 @@
-require 'bundler/setup'
+if ENV["CI"]
+  require "simplecov"
+  SimpleCov.start
+end
+
+require "bundler/setup"
 Bundler.setup
-require 'kappamaki'
+require "kappamaki"
 
 RSpec.configure do |config|
   config.color = true
-  config.order = 'random'
-  config.formatter = 'documentation'
+  config.order = "random"
+  config.formatter = "documentation"
 end

metadata

@@ -1,66 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: kappamaki
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Kevin Goslar
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-26 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  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: rspec
-  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'
+date: 2025-11-04 00:00:00.000000000 Z
+dependencies: []
 description: |2
       Kappamaki is a collection of string manipulation methods
-      that make parsing high-lever cucumber steps easier.
+      that make parsing high-level cucumber steps easier.
 email:
-- kevin.goslar@originate.com
+- kevin.goslar@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
-- ".travis.yml"
+- ".rubocop.yml"
+- CHANGELOG.md
+- DEVELOPMENT.md
 - Gemfile
 - LICENSE.txt
 - README.md
+- Rakefile
+- dprint.json
 - kappamaki.gemspec
 - lib/kappamaki.rb
 - spec/kappamaki_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/Originate/kappamaki
+homepage: https://github.com/kevgo/kappamaki
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -68,16 +44,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
-summary: Tools for natural, high-level, sophisticated Cucumber steps
+summary: Tools for defining data using natural language in Cucumber steps
 test_files: []

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-cache: bundler
-rvm: 2.1.3
-script: bundle exec rspec