kibutsu 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 626061649fb56e9beae8c3a6fe0ff0b7d88a75d7
+  data.tar.gz: 70fa236ab50e786f1f68699bc2409cb81ec678c0
+SHA512:
+  metadata.gz: 1644bbd8069590b62aeb6c9f9374b5be4d9a10d2c9b7208896a39d70497ca530084864b29bd8b45b4a8fe579b13ed9a679879198f910e0526976eaf7779f6780
+  data.tar.gz: 708578e97cb24cefe8cda8cf289f1b5e89f51a1f9fccda216c103fc7f14406f087347a9069a0eca0687fd9d888a5e66fbff07202fc1a702785c518143335d597

data/lib/kibutsu.rb

@@ -0,0 +1,26 @@
+require_relative 'kibutsu/fixture_world'
+
+#
+# Main module containing the public API of Kibutsu
+#
+module Kibutsu
+  def self.load_fixtures!(database_connection_url, fixtures_path)
+    fixture_world = FixtureWorld.instance
+    fixture_world.load(database_connection_url, fixtures_path)
+  end
+
+  def self.fixture_name_to_id(fixture_name)
+    fixture_name.to_s.hash
+  end
+
+  def self.dont_care(type)
+    case type
+    when :string
+      "don't care about this string"
+    when :number
+      0
+    when :boolean
+      false
+    end
+  end
+end

data/lib/kibutsu/database_connection.rb

@@ -0,0 +1,56 @@
+require 'sequel'
+
+require_relative 'foreign_key_column'
+
+module Kibutsu
+  # Only class that directly interacts with Sequel. Used for retrieving data
+  # from the database and inserting fixtures into it.
+  class DatabaseConnection
+    def initialize(connection_string)
+      @connection = Sequel.connect(connection_string)
+    end
+
+    def insert_fixture_tables(fixture_tables)
+      fixture_tables.each do |fixture_table|
+        insert_table(fixture_table)
+        insert_fixture_tables(fixture_table.foreign_key_source_tables)
+      end
+    end
+
+    def column_names(table_name)
+      connection.schema(table_name.to_s).map(&:first)
+    end
+
+    def foreign_key_columns(table_name)
+      connection.foreign_key_list(table_name.to_s).map do |foreign_key_info|
+        ForeignKeyColumn.new(
+          FixtureWorld.instance.find_table(table_name.to_s),
+          foreign_key_info[:columns].first.to_s,
+          FixtureWorld.instance.find_table(foreign_key_info[:table].to_s)
+        )
+      end
+    end
+
+    def table_names
+      connection.tables
+    end
+
+    private
+
+    attr_reader :connection
+
+    def insert_table(fixture_table)
+      connection[fixture_table.name.to_sym].delete
+
+      fixture_table.fixtures.each do |fixture|
+        insert_fixture(fixture)
+      end
+    end
+
+    def insert_fixture(fixture)
+      fixture_table = fixture.table
+      attributes = fixture.enriched_attributes
+      connection[fixture_table.name.to_sym].insert(attributes)
+    end
+  end
+end

data/lib/kibutsu/fixture.rb

@@ -0,0 +1,60 @@
+require 'date'
+
+module Kibutsu
+  # Corresponds to one named fixture from a fixture file.
+  class Fixture
+    TIMESTAMP_COLUMN_NAMES = %w[created_at updated_at].freeze
+
+    def initialize(table, name, attributes)
+      @table = table
+      @name = name
+      @attributes = attributes
+    end
+
+    def enriched_attributes
+      enriched_attributes = enrich_with_id(attributes)
+      enriched_attributes = enrich_with_foreign_keys(enriched_attributes)
+      enrich_with_timestamps(enriched_attributes)
+    end
+
+    attr_reader :table, :name, :attributes
+
+    private
+
+    def enrich_with_id(attr)
+      attr.merge('id' => Kibutsu.fixture_name_to_id(@name))
+    end
+
+    def enrich_with_foreign_keys(attr)
+      foreign_key_columns.each do |foreign_key_column|
+        foreign_fixture_name = foreign_table_reference(attr, foreign_key_column)
+        if foreign_fixture_name
+          attr[foreign_key_column.name] =
+            Kibutsu.fixture_name_to_id(foreign_fixture_name)
+        end
+      end
+      attr
+    end
+
+    def foreign_key_columns
+      table.foreign_key_columns
+    end
+
+    def enrich_with_timestamps(attr)
+      date_time = DateTime.now
+      TIMESTAMP_COLUMN_NAMES.each do |timestamp_column_name|
+        next unless table.column_names.include? timestamp_column_name.to_sym
+        attr[timestamp_column_name] = date_time
+      end
+      attr
+    end
+
+    def foreign_table_reference(attr, foreign_key_column)
+      attr.delete(column_name_to_model_name(foreign_key_column.name))
+    end
+
+    def column_name_to_model_name(column_name)
+      column_name.to_s[0..-4]
+    end
+  end
+end

data/lib/kibutsu/fixture_finder.rb

@@ -0,0 +1,16 @@
+module Kibutsu
+  # Finds fixture files with the right file extensions to load.
+  class FixtureFinder
+    def initialize(fixtures_path)
+      @fixtures_path = fixtures_path
+    end
+
+    def fixture_file_paths
+      Dir[File.join(fixtures_path, '**', '*.{yml,yml.erb}')]
+    end
+
+    private
+
+    attr_reader :fixtures_path
+  end
+end

data/lib/kibutsu/fixture_loader.rb

@@ -0,0 +1,52 @@
+require 'yaml'
+require 'erb'
+
+require_relative 'fixture_table'
+require_relative 'fixture'
+
+module Kibutsu
+  # Loads fixtures from files, optionally with ERB pre-processing and creates
+  # Fixture objects from them.
+  class FixtureLoader
+    def initialize(fixture_file_path, database_connection)
+      @fixture_file_path = fixture_file_path
+      @database_connection = database_connection
+    end
+
+    def load_fixture_tables
+      file_content = File.read(fixture_file_path)
+      yaml_content = if fixture_file_path.end_with? '.yml.erb'
+                       run_erb(file_content)
+                     else
+                       file_content
+                     end
+      fixtures_hash = load_fixture(yaml_content)
+      build_fixture_tables(fixtures_hash)
+    end
+
+    private
+
+    attr_reader :fixture_file_path, :database_connection
+
+    def build_fixture_tables(fixtures_hash)
+      fixtures_hash.map do |table_name, fixtures|
+        table = Kibutsu::FixtureWorld.instance.find_table(table_name)
+
+        raise "Couldn't find table with name #{table_name}" if table.nil?
+
+        fixtures.each do |fixture_name, attributes|
+          table << Kibutsu::Fixture.new(table, fixture_name, attributes)
+        end
+        table
+      end
+    end
+
+    def run_erb(file_content)
+      ERB.new(file_content).result(binding)
+    end
+
+    def load_fixture(yaml_content)
+      YAML.safe_load(yaml_content)
+    end
+  end
+end

data/lib/kibutsu/fixture_table.rb

@@ -0,0 +1,33 @@
+module Kibutsu
+  # A database table in the fixture world.
+  class FixtureTable
+    def initialize(name)
+      @name = name
+      @column_names = nil
+      @foreign_key_columns = nil
+      @foreign_key_source_tables = []
+      @fixtures = []
+    end
+
+    def <<(fixture)
+      @fixtures << fixture
+    end
+
+    def foreign_key_target_tables
+      @foreign_key_columns.map(&:target_table)
+    end
+
+    def foreign_key_columns=(foreign_key_columns)
+      @foreign_key_columns = foreign_key_columns
+
+      foreign_key_columns.each do |column|
+        column.target_table.foreign_key_source_tables << self
+      end
+    end
+
+    attr_reader(
+      :name, :fixtures, :foreign_key_source_tables, :foreign_key_columns
+    )
+    attr_accessor :column_names
+  end
+end

data/lib/kibutsu/fixture_world.rb

@@ -0,0 +1,63 @@
+require 'singleton'
+
+require_relative 'fixture_finder'
+require_relative 'fixture_loader'
+require_relative 'database_connection'
+
+module Kibutsu
+  # Singleton class that holds all the information about fixtures and fixture
+  # tables. This class really ties whole the gem together.
+  class FixtureWorld
+    include Singleton
+
+    def load(database_connection_url, fixtures_path)
+      @database_connection = Kibutsu::DatabaseConnection.new(
+        database_connection_url
+      )
+
+      load_fixtures(fixtures_path)
+      database_connection.insert_fixture_tables(tables_without_dependencies)
+    end
+
+    def load_fixtures(fixtures_path)
+      initialize_empty_fixture_tables
+      fill_fixture_table_information
+
+      fixture_file_paths = FixtureFinder.new(fixtures_path).fixture_file_paths
+      fixture_file_paths.each do |fixture_file_path|
+        FixtureLoader.new(
+          fixture_file_path, database_connection
+        ).load_fixture_tables
+      end
+    end
+
+    def find_table(table_name)
+      @fixture_tables.find { |table| table.name == table_name }
+    end
+
+    attr_reader :fixture_tables
+
+    private
+
+    attr_reader :fixtures_path, :database_connection
+
+    def initialize_empty_fixture_tables
+      @fixture_tables = database_connection.table_names.map do |table_name|
+        FixtureTable.new(table_name.to_s)
+      end
+    end
+
+    def fill_fixture_table_information
+      @fixture_tables.each do |fixture_table|
+        fixture_table.column_names =
+          database_connection.column_names(fixture_table.name)
+        fixture_table.foreign_key_columns =
+          database_connection.foreign_key_columns(fixture_table.name)
+      end
+    end
+
+    def tables_without_dependencies
+      @fixture_tables.select { |table| table.foreign_key_target_tables.none? }
+    end
+  end
+end

data/lib/kibutsu/foreign_key_column.rb

@@ -0,0 +1,12 @@
+module Kibutsu
+  # Corresponds to a foreign key column in the database.
+  class ForeignKeyColumn
+    def initialize(source_table, name, target_table)
+      @source_table = source_table
+      @name = name
+      @target_table = target_table
+    end
+
+    attr_reader :source_table, :name, :target_table
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: kibutsu
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ferdinand Niedermann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.49.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.49.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'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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: sqlite3
+  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: rubocop
+  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'
+description: |-
+  Kibutsu is an easy-to-use database fixture library.
+
+  The only dependency kibutsu has is the sequel gem. Thus, you may use it with any project that uses sequel, e.g. with a hanami app!
+email: ferdinand.niedermann@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/kibutsu.rb
+- lib/kibutsu/database_connection.rb
+- lib/kibutsu/fixture.rb
+- lib/kibutsu/fixture_finder.rb
+- lib/kibutsu/fixture_loader.rb
+- lib/kibutsu/fixture_table.rb
+- lib/kibutsu/fixture_world.rb
+- lib/kibutsu/foreign_key_column.rb
+homepage: http://rubygems.org/gems/kibutsu
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: A fixture library for sequel
+test_files: []