flat_kit 0.3.0 → 1.0.0

data/tasks/this.rb

@@ -1,208 +0,0 @@
-require 'pathname'
-
-# Public: A Class containing all the metadata and utilities needed to manage a
-# ruby project.
-class ThisProject
-  # The name of this project
-  attr_accessor :name
-
-  # The author's name
-  attr_accessor :author
-
-  # The email address of the author(s)
-  attr_accessor :email
-
-  # The homepage of this project
-  attr_accessor :homepage
-
-  # The regex of files to exclude from the manifest
-  attr_accessor :exclude_from_manifest
-
-  # The hash of Gem::Specifications keyed' by platform
-  attr_accessor :gemspecs
-
-  # Public: Initialize ThisProject
-  #
-  # Yields self
-  def initialize(&block)
-    @exclude_from_manifest = Regexp.union(/\.(git|DS_Store)/,
-                                          /^(doc|coverage|pkg|tmp|Gemfile(\.lock)?)/,
-                                          /^[^\/]+\.gemspec/,
-                                          /\.(swp|jar|bundle|so|rvmrc|travis.yml|byebug_history|fossa.yml|ruby-version)$/,
-                                          /~$/)
-    @gemspecs              = Hash.new
-    yield self if block_given?
-  end
-
-  # Public: return the version of ThisProject
-  #
-  # Search the ruby files in the project looking for the one that has the
-  # version string in it. This does not eval any code in the project, it parses
-  # the source code looking for the string.
-  #
-  # Returns a String version
-  def version
-    [ "lib/#{ name }.rb", "lib/#{ name }/version.rb" ].each do |v|
-      path = project_path( v )
-      line = path.read[/^\s*VERSION\s*=\s*.*/]
-      if line then
-        return line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
-      end
-    end
-  end
-
-  # Internal: Return a section of an RDoc file with the given section name
-  #
-  # path         - the relative path in the project of the file to parse
-  # section_name - the section out of the file from which to parse data
-  #
-  # Retuns the text of the section as an array of paragrphs.
-  def section_of( file, section_name )
-    re    = /^[=#]+ (.*)$/
-    sectional = project_path( file )
-    parts = sectional.read.split( re )[1..-1]
-    parts.map! { |p| p.strip }
-
-    sections = Hash.new
-    Hash[*parts].each do |k,v|
-      sections[k] = v.split("\n\n")
-    end
-    return sections[section_name]
-  end
-
-  # Internal: print out a warning about the give task
-  def task_warning( task )
-    warn "WARNING: '#{task}' tasks are not defined. Please run 'rake develop'"
-  end
-
-  # Internal: Return the full path to the file that is relative to the project
-  # root.
-  #
-  # path - the relative path of the file from the project root
-  #
-  # Returns the Pathname of the file
-  def project_path( *relative_path )
-    project_root.join( *relative_path )
-  end
-
-  # Internal: The absolute path of this file
-  #
-  # Returns the Pathname of this file.
-  def this_file_path
-    Pathname.new( __FILE__ ).expand_path
-  end
-
-  # Internal: The root directory of this project
-  #
-  # This is defined as being the directory that is in the path of this project
-  # that has the first Rakefile
-  #
-  # Returns the Pathname of the directory
-  def project_root
-    this_file_path.ascend do |p|
-      rakefile = p.join( 'Rakefile' )
-      return p if rakefile.exist?
-    end
-  end
-
-  # Internal: Returns the contents of the Manifest.txt file as an array
-  #
-  # Returns an Array of strings
-  def manifest
-    manifest_file = project_path( "Manifest.txt" )
-    abort "You need a Manifest.txt" unless manifest_file.readable?
-    manifest_file.readlines.map { |l| l.strip }
-  end
-
-  # Internal: Return the files that define the extensions
-  #
-  # Returns an Array
-  def extension_conf_files
-    manifest.grep( /extconf.rb\Z/ )
-  end
-
-  # Internal: Returns the gemspace associated with the current ruby platform
-  def platform_gemspec
-    gemspecs.fetch(platform) { This.ruby_gemspec }
-  end
-
-  def core_gemspec
-    Gem::Specification.new do |spec|
-      spec.name        = name
-      spec.version     = version
-      spec.author      = author
-      spec.email       = email
-      spec.homepage    = homepage
-
-      spec.summary     = summary
-      spec.description = description
-      spec.license     = license
-
-      spec.files       = manifest
-      spec.executables = spec.files.grep(/^bin/) { |f| File.basename(f) }
-      spec.test_files  = spec.files.grep(/^(spec|test)/)
-
-      spec.extra_rdoc_files += spec.files.grep(/(txt|rdoc|md)$/)
-      spec.rdoc_options = [ "--main"  , 'README.md',
-                            "--markup", "tomdoc" ]
-
-      spec.required_ruby_version = '>= 2.2.2'
-    end
-  end
-
-  # Internal: Return the gemspec for the ruby platform
-  def ruby_gemspec( core = core_gemspec, &block )
-    yielding_gemspec( 'ruby', core, &block )
-  end
-
-  # Internal: Return the gemspec for the jruby platform
-  def java_gemspec( core = core_gemspec, &block )
-    yielding_gemspec( 'java', core, &block )
-  end
-
-  # Internal: give an initial spec and a key, create a new gemspec based off of
-  # it.
-  #
-  # This will force the new gemspecs 'platform' to be that of the key, since the
-  # only reason you would have multiple gemspecs at this point is to deal with
-  # different platforms.
-  def yielding_gemspec( key, core )
-    spec = gemspecs[key] ||= core.dup
-    spec.platform = key
-    yield spec if block_given?
-    return spec
-  end
-
-  # Internal: Return the platform of ThisProject at the current moment in time.
-  def platform
-    (RUBY_PLATFORM == "java") ? 'java' : Gem::Platform::RUBY
-  end
-
-  # Internal: Return the DESCRIPTION section of the README.rdoc file
-  def description_section
-    section_of( 'README.md', 'DESCRIPTION')
-  end
-
-  # Internal: Return the summary text from the README
-  def summary
-    description_section.first
-  end
-
-  # Internal: Return the full description text from the README
-  def description
-    description_section.join(" ").tr("\n", ' ').gsub(/[{}]/,'').gsub(/\[[^\]]+\]/,'') # strip rdoc
-  end
-
-  def license
-    license_file = project_path("LICENSE.txt")
-    line = license_file.readlines.first
-    line.split(/\s+/).first
-  end
-
-  # Internal: The path to the gemspec file
-  def gemspec_file
-    project_path( "#{ name }.gemspec" )
-  end
-end
-
-This = ThisProject.new

data/test/device_dataset.rb

@@ -1,117 +0,0 @@
-class DeviceDataset
-
-  include TestHelper
-
-  attr_reader :count
-  attr_reader :compare_fields
-  attr_reader :fields
-
-  attr_reader :filename_jsonl
-  attr_reader :filename_sorted_jsonl
-  attr_reader :filename_csv
-  attr_reader :filename_sorted_csv
-
-  def initialize(count:, compare_fields: [ "manufacturer", "model_name", "slug" ])
-    @count = count
-    @compare_fields = compare_fields
-    @fields = %w[
-      build_number
-      manufacturer
-      model_name
-      platform
-      serial
-      slug
-    ]
-    @filename_sorted_jsonl = nil
-    @filename_jsonl = nil
-    @filename_sorted_csv = nil
-    @filename_csv = nil
-    @slug = generate_slug
-  end
-
-  def persist_records_as_jsonl
-    @filename_jsonl = scratch_file(prefix: "unsorted_", slug: @slug)
-    @filename_jsonl.open("w+") do |f|
-      f.write(records_as_jsonl)
-    end
-  end
-
-  def persist_sorted_records_as_jsonl
-    @filename_sorted_jsonl = scratch_file(prefix: "sorted_", slug: @slug)
-    @filename_sorted_jsonl.open("w+") do |f|
-      f.write(sorted_records_as_jsonl)
-    end
-  end
-
-  def cleanup_files
-    [ @filename_sorted_jsonl, @filename_jsonl, @filename_sorted_csv, @filename_csv ].each do |p|
-      next if p.nil?
-      p.unlink if p.exist?
-    end
-  end
-
-  def records
-    @records ||= Array.new.tap do |a|
-      count.times do
-        a << Hash.new.tap do |h|
-          fields.each do |f|
-            value = (f == 'slug') ? generate_slug : ::Faker::Device.send(f)
-            h[f] = value
-          end
-        end
-      end
-    end
-  end
-
-  def sorted_records
-    @sorted_records ||= records.sort_by do |r|
-      compare_fields.map { |field| r[field] }
-    end
-  end
-
-  def records_as_jsonl
-    @jsonl_records ||= as_jsonl(list: records)
-  end
-
-  def records_as_csv
-    @csv_records ||= as_csv(list: records)
-  end
-
-  def records_as_csv_rows
-    @csv_rows ||= as_csv_rows(records_as_csv)
-  end
-
-  def sorted_records_as_jsonl
-    @jsonl_sorted_records ||= as_jsonl(list: sorted_records)
-  end
-
-  def sorted_records_as_csv
-    @csv_sorted_records ||= as_csv(list: sorted_records)
-  end
-
-  def sorted_records_as_csv_rows
-    @csv_sorted_rows ||= as_csv_rows(sorted_records_as_csv)
-  end
-
-  private
-
-  def as_jsonl(list:)
-    list.map { |r| Oj.dump(r) }.join("\n") + "\n"
-  end
-
-  def as_csv(list:, headers: fields)
-    CSV.generate('', headers: headers , write_headers: true) do |csv|
-      list.each do |r|
-        csv << fields.map { |f| r[f] }
-      end
-    end
-  end
-
-  def as_csv_rows(text)
-    Array.new.tap do |a|
-      CSV.new(text, converters: :numeric, headers: :first_row, return_headers: false).each do |row|
-        a << row
-      end
-    end
-  end
-end

data/test/field_type/test_boolean_type.rb

@@ -1,65 +0,0 @@
-require_relative '../test_helper'
-
-module TestFieldType
-  class TestBooleanType < ::Minitest::Test
-    def truthy_items
-      t = %w[ yes Y true t 1 y ]
-      t << 1
-    end
-
-    def falsey_items
-      f = %w[ no n false f 0 N ]
-      f << 0
-    end
-
-    def test_true
-      assert(FlatKit::FieldType::BooleanType.matches?(true))
-    end
-
-    def test_false
-      assert(FlatKit::FieldType::BooleanType.matches?(false))
-    end
-
-    def test_truthy_items
-      truthy_items.each do |s|
-        assert(FlatKit::FieldType::BooleanType.matches?(s), "#{s} should be boolean")
-      end
-    end
-
-    def test_falsey_items
-      falsey_items.each do |s|
-        assert(FlatKit::FieldType::BooleanType.matches?(s), "#{s} should be boolean")
-      end
-    end
-
-    def test_other_class_does_not_match
-      refute(FlatKit::FieldType::BooleanType.matches?(Object.new))
-    end
-
-    def test_coerces_falsey_to_boolean
-      falsey_items.each do |t|
-        refute(FlatKit::FieldType::BooleanType.coerce(t))
-      end
-    end
-
-    def test_true_is_truthy
-      assert(FlatKit::FieldType::BooleanType.coerce(true))
-    end
-
-    def test_false_is_falsey
-      refute(FlatKit::FieldType::BooleanType.coerce(false))
-    end
-
-    def test_0_is_false
-      refute(FlatKit::FieldType::BooleanType.coerce(0))
-    end
-
-    def test_1_is_false
-      assert(FlatKit::FieldType::BooleanType.coerce(1))
-    end
-
-    def test_42_is_false
-      assert(FlatKit::FieldType::BooleanType.coerce(42.0))
-    end
-  end
-end

data/test/field_type/test_date_type.rb

@@ -1,71 +0,0 @@
-require_relative '../test_helper'
-
-module TestFieldType
-  class TestDateType < ::Minitest::Test
-    def test_time_does_not_match
-      refute(FlatKit::FieldType::DateType.matches?(Time.now))
-    end
-
-    def test_date
-      assert(FlatKit::FieldType::DateType.matches?(Date.today))
-    end
-
-    def test_datetime_does_not_match
-      refute(FlatKit::FieldType::DateType.matches?(DateTime.now))
-    end
-
-    def test_formats
-      formats = ::FlatKit::FieldType::DateType.parse_formats
-
-      assert_equal(formats.size, formats.sort.uniq.size)
-
-      formats.each do |df|
-        s = Time.now.strftime("#{df}")
-        assert(FlatKit::FieldType::DateType.matches?(s), "#{s} should match date")
-      end
-    end
-
-    def test_other_class_does_not_match
-      [ 42, Object.new, true, false ].each do |x|
-        refute(FlatKit::FieldType::DateType.matches?(x), "#{x} should not be date")
-      end
-    end
-
-    def test_N_number_does_not_match
-      x = "N89362"
-      refute(FlatKit::FieldType::DateType.matches?(x), "#{x} should not be date")
-    end
-
-    def test_coerce
-      formats = ::FlatKit::FieldType::DateType.parse_formats
-
-      formats.each do |df|
-        s = Time.now.strftime("#{df}")
-        assert_instance_of(Date, FlatKit::FieldType::DateType.coerce(s), "#{s} should convert to date")
-      end
-    end
-
-    def test_date_coerce_does_not_passthrough_time
-      t = Time.now
-      assert_equal(::FlatKit::FieldType::CoerceFailure, FlatKit::FieldType::DateType.coerce(t))
-    end
-
-    def test_date_coerce_passthrough_date
-      t = Date.today
-      assert_equal(t, FlatKit::FieldType::DateType.coerce(t))
-    end
-
-    def test_date_coerce_does_not_passthrough_datetime
-      t = DateTime.now
-      assert_equal(::FlatKit::FieldType::CoerceFailure, FlatKit::FieldType::DateType.coerce(t))
-    end
-
-    def test_number_coerce_failure
-      assert_equal(::FlatKit::FieldType::CoerceFailure, FlatKit::FieldType::DateType.coerce(42))
-    end
-
-    def test_number_coerce_failure_bad_parse
-      assert_equal(::FlatKit::FieldType::CoerceFailure, FlatKit::FieldType::DateType.coerce("1234 56 78 90"))
-    end
-  end
-end

data/test/field_type/test_float_type.rb

@@ -1,56 +0,0 @@
-require_relative '../test_helper'
-
-module TestFieldType
-  class TestFloatType < ::Minitest::Test
-    def test_float_matches
-      assert(FlatKit::FieldType::FloatType.matches?(42.0))
-      assert(FlatKit::FieldType::FloatType.matches?(42.1))
-    end
-
-    def test_integer_does_not_match
-      refute(FlatKit::FieldType::FloatType.matches?(42))
-    end
-
-    def test_string_of_digits_does_not_match
-      refute(FlatKit::FieldType::FloatType.matches?("42"))
-    end
-
-    def test_string_of_digits_with_dot_matches
-      assert(FlatKit::FieldType::FloatType.matches?("42.0"))
-    end
-
-    def test_string_of_leters_does_not_match
-      refute(FlatKit::FieldType::FloatType.matches?("abc"))
-    end
-
-    def test_scientific_notation_matches
-      assert(FlatKit::FieldType::FloatType.matches?("1e-10"))
-    end
-
-    def test_other_class_does_not_match
-      refute(FlatKit::FieldType::FloatType.matches?(Object.new))
-    end
-
-    def test_integer_coerces
-      assert_equal(42.0, ::FlatKit::FieldType::FloatType.coerce(42))
-    end
-
-    def test_integer_strings_coerce
-      assert_equal(42.0, ::FlatKit::FieldType::FloatType.coerce("42"))
-    end
-
-    def test_float_strings_coerce
-      assert_equal(42.6, ::FlatKit::FieldType::FloatType.coerce("42.6"))
-    end
-
-    def test_float_coerces
-      assert_equal(42.6, ::FlatKit::FieldType::FloatType.coerce(42.6))
-    end
-
-    def test_non_numercic_do_not_coerce
-      [ "eleven", nil, false, Object.new ].each do |nope|
-        assert_equal(::FlatKit::FieldType::CoerceFailure, ::FlatKit::FieldType::FloatType.coerce(nope))
-      end
-    end
-  end
-end

data/test/field_type/test_guess_type.rb

@@ -1,14 +0,0 @@
-require_relative '../test_helper'
-
-module TestFieldType
-  class TestGuessType < ::Minitest::Test
-
-    def test_guess_type_should_not_match_anything
-      refute(FlatKit::FieldType::GuessType.matches?(nil))
-    end
-
-    def test_guess_type_returns_coerce_failure
-      assert_equal(::FlatKit::FieldType::CoerceFailure, ::FlatKit::FieldType::GuessType.coerce(nil))
-    end
-  end
-end

data/test/field_type/test_integer_type.rb

@@ -1,52 +0,0 @@
-require_relative '../test_helper'
-
-module TestFieldType
-  class TestIntegerType < ::Minitest::Test
-    def test_matches_integer
-      assert(FlatKit::FieldType::IntegerType.matches?(42))
-    end
-
-    def test_matches_negative_integer
-      assert(FlatKit::FieldType::IntegerType.matches?("-42"))
-    end
-
-    def test_float_does_not_match
-      refute(FlatKit::FieldType::IntegerType.matches?(42.0))
-    end
-
-    def test_string_of_digits_matches
-      assert(FlatKit::FieldType::IntegerType.matches?("42"))
-    end
-
-    def test_string_with_some_digiets_does_not_match
-      refute(FlatKit::FieldType::IntegerType.matches?("42.0"))
-      refute(FlatKit::FieldType::IntegerType.matches?("abc"))
-    end
-
-    def test_other_class_does_not_match
-      refute(FlatKit::FieldType::IntegerType.matches?(Object.new))
-    end
-
-    def test_integer_coerces
-      assert_equal(42, ::FlatKit::FieldType::IntegerType.coerce(42))
-    end
-
-    def test_integer_strings_coerce
-      assert_equal(42, ::FlatKit::FieldType::IntegerType.coerce("42"))
-    end
-
-    def test_float_coerces
-      assert_equal(42, ::FlatKit::FieldType::IntegerType.coerce(42.6))
-    end
-
-    def test_float_strings_do_not_coerce
-      assert_equal(::FlatKit::FieldType::CoerceFailure, ::FlatKit::FieldType::IntegerType.coerce("42.6"))
-    end
-
-    def test_non_numercic_do_not_coerce
-      [ "eleven", nil, false, Object.new ].each do |nope|
-        assert_equal(::FlatKit::FieldType::CoerceFailure, ::FlatKit::FieldType::IntegerType.coerce(nope))
-      end
-    end
-  end
-end

data/test/field_type/test_null_type.rb

@@ -1,41 +0,0 @@
-require_relative '../test_helper'
-
-module TestFieldType
-  class TestNullType < ::Minitest::Test
-    def nully_items
-      [ "null", "NULL", "nil", "\\N" ]
-    end
-
-    def test_null
-      assert(FlatKit::FieldType::NullType.matches?(nil))
-    end
-
-    def test_nully_items
-      nully_items.each do |s|
-        assert(FlatKit::FieldType::NullType.matches?(s), "#{s} should be null")
-      end
-    end
-
-    def test_other_class_does_not_match
-      [ 42, Object.new, true, false ].each do |x|
-        refute(FlatKit::FieldType::NullType.matches?(x), "#{x} should not be == null")
-      end
-    end
-
-    def test_coerce_coerces_nil
-      assert_nil(FlatKit::FieldType::NullType.coerce(nil))
-    end
-
-    def test_coerces_nully_items
-      nully_items.each do |s|
-        assert_nil(FlatKit::FieldType::NullType.coerce(s))
-      end
-    end
-
-    def test_coerce_failure_non_non_nully_items
-      [ "whatever", 42, Object.new, true, false, Class].each do |x|
-        assert_equal(::FlatKit::FieldType::CoerceFailure, FlatKit::FieldType::NullType.coerce(x))
-      end
-    end
-  end
-end

data/test/field_type/test_string_type.rb

@@ -1,18 +0,0 @@
-require_relative '../test_helper'
-
-module TestFieldType
-  class TestStringType < ::Minitest::Test
-
-    def test_string_will_not_match_non_string_data
-      [42, false, true, 12.5, Object.new].each do |o|
-        refute(FlatKit::FieldType::StringType.matches?(o))
-      end
-    end
-
-    def test_string_type_returns_coerce_failures
-      [BasicObject.new].each do |o|
-        assert_equal(::FlatKit::FieldType::CoerceFailure, ::FlatKit::FieldType::StringType.coerce(o))
-      end
-    end
-  end
-end