key_value_name 0.0.1 → 0.1.0

data/lib/key_value_name/spec.rb

@@ -5,9 +5,10 @@ module KeyValueName
   # Specify the keys and value types for a KeyValueName.
   #
   class Spec
-    def initialize(marshalers, extension)
+    def initialize(marshalers, prefix = nil, suffix = nil)
       @marshalers = marshalers
-      @extension = extension
+      @prefix = prefix
+      @suffix = suffix
       @matcher = build_matcher
 
       marshalers.freeze
@@ -15,38 +16,58 @@ module KeyValueName
     end
 
     attr_reader :marshalers
-    attr_reader :extension
+    attr_reader :prefix
+    attr_reader :suffix
     attr_reader :matcher
 
-    def matches?(string)
-      string =~ matcher
+    def matches?(basename)
+      basename =~ matcher
     end
 
-    def read(string)
-      raise ArgumentError, "bad filename: #{string}" unless string =~ matcher
+    def glob
+      if marshalers.any?
+        "#{prefix}*#{suffix}"
+      else
+        "#{prefix}#{suffix}"
+      end
+    end
+
+    def parse(basename)
+      raise ArgumentError, "bad name: #{basename}" unless matcher =~ basename
       Hash[marshalers.map.with_index do |(key, marshaler), index|
-        [key, marshaler.read(Regexp.last_match(index + 1))]
+        [key, marshaler.parse(Regexp.last_match(index + 1))]
       end]
     end
 
-    def write(name)
-      string = name.each_pair.map do |key, value|
-        value_string = marshalers[key].write(value)
+    def generate(struct)
+      body = struct.each_pair.map do |key, value|
+        value_string = marshalers[key].generate(value)
         "#{key}#{KEY_VALUE_SEPARATOR}#{value_string}"
       end.join(PAIR_SEPARATOR)
-      string += ".#{extension}" unless extension.nil?
-      string
+      "#{prefix}#{body}#{suffix}"
+    end
+
+    def compare(a, b)
+      return 0 if a.nil? && b.nil?
+      return nil if a.nil? || b.nil?
+      a.each_pair do |key, value|
+        marshaler = marshalers[key]
+        a_comparable = marshaler.to_comparable(value)
+        b_comparable = marshaler.to_comparable(b[key])
+        signum = a_comparable <=> b_comparable
+        return signum if signum != 0
+      end
+      0
     end
 
-    private
+    protected
 
     def build_matcher
       pair_rxs = marshalers.map do |name, marshaler|
         /#{name}#{KEY_VALUE_SEPARATOR}(#{marshaler.matcher})/
       end
-      pairs_matcher = pair_rxs.map(&:to_s).join(PAIR_SEPARATOR_RX.to_s)
-      extension_matcher = extension.nil? ? '' : /[.]#{extension}/.to_s
-      Regexp.new('\A' + pairs_matcher + extension_matcher + '\z')
+      body = pair_rxs.map(&:to_s).join(PAIR_SEPARATOR_RX.to_s)
+      Regexp.new("\\A#{prefix}#{body}#{suffix}\\z")
     end
   end
 end

data/lib/key_value_name/version.rb

@@ -2,7 +2,7 @@
 
 module KeyValueName
   VERSION_MAJOR = 0
-  VERSION_MINOR = 0
-  VERSION_PATCH = 1
+  VERSION_MINOR = 1
+  VERSION_PATCH = 0
   VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH].join('.')
 end

data/lib/key_value_name.rb

@@ -9,18 +9,38 @@ module KeyValueName
   PAIR_SEPARATOR = '.'
   PAIR_SEPARATOR_RX = /[.]/
 
+  def self.camelize(name)
+    name.to_s.gsub(/(?:\A|_)(.)/) { Regexp.last_match(1).upcase }
+  end
+
   def self.check_symbol(name)
-    raise ArgumentError, "bad symbol: #{name}" unless name =~ /\A#{KEY_RX}\z/
+    raise ArgumentError, "bad symbol: #{name}" unless
+      name.match?(/\A#{KEY_RX}\z/)
+    raise ArgumentError, "reserved symbol: #{name}" if
+      %i[parent].member?(name)
+  end
+
+  def self.new(name = nil, &block)
+    raise unless block_given?
+    FileBuilder.new(name, &block).build
   end
 
-  def self.new
-    builder = Builder.new
-    yield builder
-    builder.build
+  def self.schema(&block)
+    raise unless block_given?
+    SchemaBuilder.new(&block).build
   end
 end
 
 require_relative 'key_value_name/version'
 require_relative 'key_value_name/marshalers'
+require_relative 'key_value_name/schema'
+require_relative 'key_value_name/collection'
+require_relative 'key_value_name/mixins/name'
+require_relative 'key_value_name/mixins/file_name'
+require_relative 'key_value_name/mixins/folder_name'
 require_relative 'key_value_name/spec'
-require_relative 'key_value_name/builder'
+require_relative 'key_value_name/builders/key_value_builder'
+require_relative 'key_value_name/builders/container_builder'
+require_relative 'key_value_name/builders/schema_builder'
+require_relative 'key_value_name/builders/file_builder'
+require_relative 'key_value_name/builders/folder_builder'

data/test/key_value_name/extension_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require 'key_value_name'
+
+class TestExtension < Minitest::Test
+  ExtensionSchema = KeyValueName.schema do
+    file :foo
+
+    file :foo, :tar
+
+    file :foo, :tar, :gz
+
+    file :bar, :tar do
+      key :a, type: Integer
+    end
+
+    file :bar, :tar, :gz do
+      key :a, type: Integer
+    end
+  end
+
+  def test_extensions
+    Dir.mktmpdir do |tmp|
+      schema = ExtensionSchema.new(root: tmp)
+
+      foo = schema.foo
+      assert_equal File.join(tmp, 'foo'), foo.to_s
+      assert_match(/ExtensionSchema::Foo\z/, foo.class.to_s)
+
+      foo_tar = schema.foo_tar
+      assert_equal File.join(tmp, 'foo.tar'), foo_tar.to_s
+      assert_match(/ExtensionSchema::FooTar\z/, foo_tar.class.to_s)
+
+      foo_tar_gz = schema.foo_tar_gz
+      assert_equal File.join(tmp, 'foo.tar.gz'), foo_tar_gz.to_s
+      assert_match(/ExtensionSchema::FooTarGz\z/, foo_tar_gz.class.to_s)
+
+      bar_tar = schema.bar_tar.new(a: 1)
+      assert_equal File.join(tmp, 'bar-a-1.tar'), bar_tar.to_s
+      assert_match(/ExtensionSchema::BarTar\z/, bar_tar.class.to_s)
+
+      bar_tar_gz = schema.bar_tar_gz.new(a: 1)
+      assert_equal File.join(tmp, 'bar-a-1.tar.gz'), bar_tar_gz.to_s
+      assert_match(/ExtensionSchema::BarTarGz\z/, bar_tar_gz.class.to_s)
+    end
+  end
+end

data/test/key_value_name/file_builder_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require 'key_value_name'
+
+class TestFileBuilder < Minitest::Test
+  OneFolderSetSchema = KeyValueName.schema do
+    file :foo do
+      key :a, type: Integer
+    end
+  end
+
+  OneFolderSetOneFileSchema = KeyValueName.schema do
+    folder :foo do
+      key :a, type: Integer
+      file :bar
+    end
+  end
+
+  def test_one_folder_set_schema
+    Dir.mktmpdir do |tmp|
+      schema = OneFolderSetSchema.new(root: tmp)
+      assert_equal [], schema.foo.all
+
+      foos = Array.new(3) do |i|
+        schema.foo.new(a: i).touch!
+      end
+
+      assert_equal [foos[1]], schema.foo.where(a: 1)
+      assert_equal foos[1], schema.foo.find_by(a: 1)
+    end
+  end
+
+  def test_file_destroy!
+    Dir.mktmpdir do |tmp|
+      schema = OneFolderSetOneFileSchema.new(root: tmp)
+
+      # Should suceed even if parent directory does not exist.
+      foo = schema.foo.new(a: 1)
+      assert !foo.exist?
+      foo.bar.destroy!
+      assert !foo.bar.exist?
+
+      foo.bar.touch!
+      assert foo.bar.exist?
+      foo.bar.destroy!
+      assert !foo.bar.exist?
+    end
+  end
+
+  def test_file_mkdir!
+    Dir.mktmpdir do |tmp|
+      schema = OneFolderSetOneFileSchema.new(root: tmp)
+
+      foo = schema.foo.new(a: 1)
+      bar = foo.bar.mkdir!
+      assert_equal File.join(foo.to_s, 'bar'), bar.to_s
+      assert_equal [foo], schema.foo.all
+      assert foo.exist?
+      assert !bar.exist?
+    end
+  end
+end

data/test/key_value_name/folder_builder_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require 'key_value_name'
+
+class TestFolderBuilder < Minitest::Test
+  OneFolderSetSchema = KeyValueName.schema do
+    folder :foo do
+      key :a, type: Integer
+    end
+  end
+
+  def test_one_folder_set_schema
+    Dir.mktmpdir do |tmp|
+      schema = OneFolderSetSchema.new(root: tmp)
+      assert_equal [], schema.foo.all
+
+      foos = Array.new(3) do |i|
+        schema.foo.new(a: i).mkdir!
+      end
+
+      assert_equal [foos[1]], schema.foo.where(a: 1)
+      assert_equal foos[1], schema.foo.find_by(a: 1)
+    end
+  end
+end

data/test/key_value_name/key_value_name_test.rb

@@ -6,54 +6,58 @@ require 'tmpdir'
 
 require 'key_value_name'
 
-class TestKeyValueName < MiniTest::Test
-  TestInteger = KeyValueName.new do |n|
-    n.key :a, type: Numeric, format: '%d'
+class TestKeyValueName < Minitest::Test
+  TestInteger = KeyValueName.new do
+    key :a, type: Integer, format: '%d'
   end
 
-  TestHexNumeric = KeyValueName.new do |n|
-    n.key :b, type: Numeric, format: '%x'
+  TestHexNumeric = KeyValueName.new do
+    key :b, type: Integer, format: '%x'
   end
 
-  TestFormattedNumeric = KeyValueName.new do |n|
-    n.key :c, type: Numeric, format: '%.3f', scan_format: '%f'
+  TestFormattedNumeric = KeyValueName.new do
+    key :c, type: Float, format: '%.3f'
   end
 
-  TestPaddedNumeric = KeyValueName.new do |n|
-    n.key :d, type: Numeric, format: '%04d'
+  TestPaddedNumeric = KeyValueName.new do
+    key :d, type: Integer, format: '%04d'
   end
 
-  TestSymbol = KeyValueName.new do |n|
-    n.key :a, type: Symbol
+  TestSymbol = KeyValueName.new do
+    key :a, type: Symbol
   end
 
-  TestFloat = KeyValueName.new do |n|
-    n.key :a, type: Numeric
+  TestFloat = KeyValueName.new do
+    key :a, type: Float
   end
 
-  TestTwoIntegers = KeyValueName.new do |n|
-    n.include_keys TestInteger
-    n.include_keys TestHexNumeric
+  TestTwoIntegers = KeyValueName.new do
+    include_keys TestInteger
+    include_keys TestHexNumeric
   end
 
-  TestMixed = KeyValueName.new do |n|
-    n.key :id, type: Symbol
-    n.key :ordinal, type: Numeric, format: '%d'
-    n.key :value, type: Numeric
+  TestMixed = KeyValueName.new do
+    key :id, type: Symbol
+    key :ordinal, type: Integer
+    key :value, type: Float
   end
 
-  TestExtension = KeyValueName.new do |n|
-    n.key :big_number, type: Numeric, format: '%04d'
-    n.extension 'bin'
+  TestExtension = KeyValueName.new do
+    key :big_number, type: Integer, format: '%04d'
+    extension 'bin'
   end
 
-  TestEKey = KeyValueName.new do |n|
-    n.key :x, type: Numeric
-    n.key :e, type: Numeric
+  TestEKey = KeyValueName.new do
+    key :x, type: Float
+    key :e, type: Float
+  end
+
+  TestBoolean = KeyValueName.new do
+    key :a, type: :boolean
   end
 
   def roundtrip(klass, string, args)
-    name = klass.read(string)
+    name = klass.parse(string)
     assert_equal args.keys, name.to_h.keys
     args.each do |key, value|
       assert_equal value, name[key]
@@ -76,7 +80,7 @@ class TestKeyValueName < MiniTest::Test
   end
 
   def test_formatted_numeric_parse
-    assert_equal(-0.0013, TestFormattedNumeric.read('c--1.3e-3').c)
+    assert_equal(-0.0013, TestFormattedNumeric.parse('c--1.3e-3').c)
   end
 
   def test_padded_numeric_roundtrip
@@ -95,6 +99,13 @@ class TestKeyValueName < MiniTest::Test
     roundtrip(TestFloat, 'a-2.25', a: 2.25)
   end
 
+  def test_exponent_float_roundtrip
+    roundtrip(TestFloat, 'a-1e+06', a: 1e6)
+    roundtrip(TestFloat, 'a--1e+06', a: -1e6)
+    roundtrip(TestFloat, 'a-1e-06', a: 1e-6)
+    roundtrip(TestFloat, 'a--1e-06', a: -1e-6)
+  end
+
   def test_two_integers_roundtrip
     roundtrip(TestTwoIntegers, 'a-123.b-ff', a: 123, b: 255)
   end
@@ -121,27 +132,39 @@ class TestKeyValueName < MiniTest::Test
     roundtrip(TestEKey, 'x-1.e-2', x: 1, e: 2)
   end
 
+  def test_boolean_roundtrip
+    roundtrip(TestBoolean, 'a-true', a: true)
+    roundtrip(TestBoolean, 'a-false', a: false)
+  end
+
   def test_missing_key
     assert_raises do
       TestInteger.new(b: 3)
     end
     assert_raises(ArgumentError) do
-      TestInteger.read('b-3')
+      TestInteger.parse('b-3')
     end
   end
 
-  def test_in_folder
-    assert_equal File.join('foo', 'a-1'), TestInteger.new(a: 1).in('foo')
-  end
-
   def test_glob_with_integers
     Dir.mktmpdir do |tmp|
-      FileUtils.touch TestInteger.new(a: 1).in(tmp)
-      FileUtils.touch TestInteger.new(a: 2).in(tmp)
+      FileUtils.touch File.join(tmp, TestInteger.new(a: 1).to_s)
+      FileUtils.touch File.join(tmp, TestInteger.new(a: 2).to_s)
       names = TestInteger.glob(tmp).sort_by(&:a)
       assert_equal 2, names.size
       assert_equal 1, names[0].a
       assert_equal 2, names[1].a
     end
   end
+
+  def test_sortable
+    names = [TestInteger.new(a: 2), TestInteger.new(a: 1)]
+    assert_equal [1, 2], names.sort.map(&:a)
+
+    names = [TestInteger.new(a: 1), TestInteger.new(a: 1)]
+    assert_equal [1, 1], names.sort.map(&:a)
+
+    names = [TestBoolean.new(a: true), TestBoolean.new(a: false)]
+    assert_equal [false, true], names.sort.map(&:a)
+  end
 end

data/test/key_value_name/schema_test.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'tmpdir'
+
+require 'key_value_name'
+
+class TestSchema < Minitest::Test
+  OneFileSchema = KeyValueName.schema do
+    file :foo
+  end
+
+  OneFileSetSchema = KeyValueName.schema do
+    file :foo do
+      key :a, type: Integer
+    end
+  end
+
+  OneFolderSchema = KeyValueName.schema do
+    folder :foo
+  end
+
+  OneFolderSetSchema = KeyValueName.schema do
+    folder :foo do
+      key :a, type: Integer
+    end
+  end
+
+  OneFolderSetOneFileSchema = KeyValueName.schema do
+    folder :foo do
+      key :a, type: Integer
+      file :bar
+    end
+  end
+
+  OneFolderSetOneFolderSchema = KeyValueName.schema do
+    folder :foo do
+      key :a, type: Integer
+      folder :bar
+    end
+  end
+
+  OneFolderSetOneFolderSetSchema = KeyValueName.schema do
+    folder :foo do
+      key :a, type: Integer
+      folder :bar do
+        key :b, type: Symbol
+      end
+    end
+  end
+
+  TripleNestedSchema = KeyValueName.schema do
+    folder :foo do
+      key :a, type: Integer
+      folder :bar do
+        key :b, type: Integer
+        folder :baz do
+          key :c, type: Integer
+        end
+      end
+    end
+  end
+
+  CustomClassNameSchema = KeyValueName.schema do
+    folder :foo, class_name: :CustomFoo do
+      file :bar, class_name: :CustomBar
+    end
+  end
+
+  def test_one_file_schema
+    Dir.mktmpdir do |tmp|
+      schema = OneFileSchema.new(root: tmp)
+      foo = schema.foo
+      assert !foo.exist?
+
+      assert_equal File.join(tmp, 'foo'), foo.to_s
+
+      foo.touch!
+      assert foo.exist?
+
+      foo.destroy!
+      assert !foo.exist?
+    end
+  end
+
+  def test_one_file_set_schema
+    Dir.mktmpdir do |tmp|
+      schema = OneFileSetSchema.new(root: tmp)
+      assert_equal [], schema.foo.all
+
+      foo1 = schema.foo.new(a: 1)
+      assert_equal File.join(tmp, 'foo-a-1'), foo1.to_s
+      assert_equal 1, foo1.a
+
+      foo2 = schema.foo.new(a: 2)
+      assert_equal File.join(tmp, 'foo-a-2'), foo2.to_s
+      assert_equal 2, foo2.a
+    end
+  end
+
+  def test_one_folder_schema
+    Dir.mktmpdir do |tmp|
+      schema = OneFolderSchema.new(root: tmp)
+      foo = schema.foo
+      assert !foo.exist?
+
+      assert_equal File.join(tmp, 'foo'), foo.to_s
+
+      foo.mkdir!
+      assert foo.exist?
+
+      foo.destroy!
+      assert !foo.exist?
+    end
+  end
+
+  def test_one_folder_set_schema
+    Dir.mktmpdir do |tmp|
+      schema = OneFolderSetSchema.new(root: tmp)
+      assert_equal [], schema.foo.all
+
+      foo1 = schema.foo.new(a: 1)
+      assert_equal File.join(tmp, 'foo-a-1'), foo1.to_s
+      assert_equal 1, foo1.a
+
+      foo2 = schema.foo.new(a: 2)
+      assert_equal File.join(tmp, 'foo-a-2'), foo2.to_s
+      assert_equal 2, foo2.a
+    end
+  end
+
+  def test_one_folder_set_one_file_schema
+    Dir.mktmpdir do |tmp|
+      schema = OneFolderSetOneFileSchema.new(root: tmp)
+
+      foo = schema.foo.new(a: 1)
+      bar = foo.bar
+      assert_equal File.join(tmp, 'foo-a-1', 'bar'), bar.to_s
+
+      bar.touch!
+      assert bar.exist?
+
+      bar.destroy!
+      assert !bar.exist?
+    end
+  end
+
+  def test_one_folder_set_one_folder_schema
+    Dir.mktmpdir do |tmp|
+      schema = OneFolderSetOneFolderSchema.new(root: tmp)
+
+      foo = schema.foo.new(a: 1)
+      bar = foo.bar
+      assert_equal File.join(tmp, 'foo-a-1', 'bar'), bar.to_s
+
+      bar.mkdir!
+      assert bar.exist?
+
+      bar.destroy!
+      assert !bar.exist?
+    end
+  end
+
+  def test_one_folder_set_one_folder_set_schema
+    Dir.mktmpdir do |tmp|
+      schema = OneFolderSetOneFolderSetSchema.new(root: tmp)
+
+      foo = schema.foo.new(a: 1)
+      bar = foo.bar.new(b: :c)
+      assert_equal File.join(tmp, 'foo-a-1', 'bar-b-c'), bar.to_s
+
+      bar.mkdir!
+      assert_equal [bar], foo.bar.all
+
+      bar.destroy!
+      assert_equal [], foo.bar.all
+    end
+  end
+
+  def test_triple_nested_schema
+    Dir.mktmpdir do |tmp|
+      schema = TripleNestedSchema.new(root: tmp)
+
+      foo = schema.foo.new(a: 1)
+      bar = foo.bar.new(b: 2)
+      baz = bar.baz.new(c: 3)
+      assert_equal \
+        File.join(tmp, 'foo-a-1', 'bar-b-2', 'baz-c-3'), baz.to_s
+
+      baz.mkdir!
+      assert_equal [baz], bar.baz.all
+
+      baz.destroy!
+      assert_equal [], bar.baz.all
+
+      foo.destroy!
+      assert_equal [], schema.foo.all
+    end
+  end
+
+  def test_parent
+    Dir.mktmpdir do |tmp|
+      schema = TripleNestedSchema.new(root: tmp)
+
+      foo = schema.foo.new(a: 1)
+      bar = foo.bar.new(b: 2)
+      baz = bar.baz.new(c: 3)
+
+      assert_nil schema.parent
+      assert_equal schema, foo.parent
+      assert_equal foo, bar.parent
+      assert_equal bar, baz.parent
+      assert_equal foo, baz.parent.parent
+    end
+  end
+
+  def test_reserved_keys
+    error = assert_raises(ArgumentError) do
+      KeyValueName.schema do
+        file :parent
+      end
+    end
+    assert_match(/reserved symbol/, error.message)
+
+    error = assert_raises(ArgumentError) do
+      KeyValueName.schema do
+        folder :parent
+      end
+    end
+    assert_match(/reserved symbol/, error.message)
+
+    error = assert_raises(ArgumentError) do
+      KeyValueName.schema do
+        folder :foo do
+          key :parent, type: Integer
+        end
+      end
+    end
+    assert_match(/reserved symbol/, error.message)
+  end
+
+  def test_custom_class_name
+    Dir.mktmpdir do |tmp|
+      schema = CustomClassNameSchema.new(root: tmp)
+
+      foo = schema.foo
+      assert_match(/CustomClassNameSchema::CustomFoo\z/, foo.class.to_s)
+
+      bar = foo.bar
+      assert_match(
+        /CustomClassNameSchema::CustomFoo::CustomBar\z/,
+        bar.class.to_s
+      )
+    end
+  end
+end