manifold-cli 0.0.7 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f50907061a12bacfb9d34d83f56fcf6bc98317c6516a216340450fef78cebe3f
-  data.tar.gz: b1722162e241d3b7275bd5675c457ce53c264d425885cc1bf35b9ae4bc62db99
+  metadata.gz: 1eb276f49eed54c682bf10a9edc53c567a4e61c1dc2c7ee1b27e98596c91d81f
+  data.tar.gz: 3e9374eeb7c36b5a5cd99b17a1d168b363ee161c23ffcae3ec54a170401ae34f
 SHA512:
-  metadata.gz: aa63a9e3a52d441d6f742efb8bab2037d67f2d12b11f8f22b835949ae3be26c3e7a01a2b15b288fcc9c9222fccd2ccb4ade3f091f01f52c678caded9fcf6733a
-  data.tar.gz: df8807050b34f49d84741afcfad06a9c4d20406f3e67e8ad9a531fc523d47d120f630693660624ff1a2a6ba3c19d485bb7bc6340d7e70bd2aebe96f425821668
+  metadata.gz: d1760a9ee8d1f2a8c78521761168696e50d87d6ca1194feb68f6a4c8a552d112624ba9c5512226f042bacedee1ae490a55f2e8ec33179e2cc588e26eb8f8e302
+  data.tar.gz: 57ff9863d1ce37d21ac58cdc8b634449754106a2472a3d1bfbebd6332d302b1ec39377ffb5dad882091df5b500bbb654c0ea385e2a60190486f903701a4d8035

data/.rubocop.yml

@@ -3,7 +3,8 @@ inherit_from: .rubocop_todo.yml
 require: rubocop-rspec
 
 AllCops:
-  TargetRubyVersion: 3.0
+  NewCops: enable
+  TargetRubyVersion: 3.2
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes

data/README.md

@@ -61,7 +61,29 @@ manifold add <data_project_name>
 After you fill out the manifold.yml file, this command generates the necessary BigQuery schema files based on the specified dimensions and metrics.
 
 ```bash
-manifold generate <data_project_name> bq
+manifold generate
+```
+
+4. **Generate Terraform Configuration (Optional)**
+
+Manifold can optionally generate Terraform configurations for managing your BigQuery resources. To generate both BigQuery schemas and Terraform configurations, use the `--tf` flag:
+
+```bash
+manifold generate --tf
+```
+
+This will create:
+
+- A root `main.tf.json` file that sets up the Google Cloud provider and workspace modules
+- Individual workspace configurations in `workspaces/<workspace_name>/main.tf.json`
+- Dataset and table definitions that reference your generated BigQuery schemas
+
+The generated Terraform configurations use the Google Cloud provider and expect a `project_id` variable to be set. You can apply these configurations using standard Terraform commands:
+
+```bash
+terraform init
+terraform plan -var="project_id=your-project-id"
+terraform apply -var="project_id=your-project-id"
 ```
 
 ## Manifold Configuration

data/bin/manifold

@@ -4,6 +4,6 @@
 lib_path = File.expand_path("../lib", Dir.pwd)
 $LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
 
-require "manifold/cli"
+require "manifold"
 
 Manifold::CLI.start(ARGV)

data/lib/manifold/api/project.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Manifold
+  module API
+    # Projects API
+    class Project
+      attr_reader :name, :logger, :directory
+
+      def initialize(name, logger: Logger.new($stdout), directory: Pathname.pwd.join(name))
+        @name = name
+        @logger = logger
+        @directory = Pathname(directory)
+      end
+
+      def self.create(name, directory: Pathname.pwd.join(name))
+        new(name, directory:).tap do |project|
+          [project.workspaces_directory, project.vectors_directory].each(&:mkpath)
+        end
+      end
+
+      def workspaces
+        @workspaces ||= workspace_directories.map { |dir| Workspace.from_directory(dir, logger:) }
+      end
+
+      def generate(with_terraform: false)
+        workspaces.each { |w| w.generate(with_terraform:) }
+        generate_terraform_entrypoint if with_terraform
+      end
+
+      def workspaces_directory
+        directory.join("workspaces")
+      end
+
+      def vectors_directory
+        directory.join("vectors")
+      end
+
+      private
+
+      def workspace_directories
+        workspaces_directory.children.select(&:directory?)
+      end
+
+      def generate_terraform_entrypoint
+        config = Terraform::ProjectConfiguration.new(workspaces)
+        config.write(directory.join("main.tf.json"))
+      end
+    end
+  end
+end

data/lib/manifold/api/vector.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Manifold
+  module API
+    # Describes the entities for whom metrics are calculated.
+    class Vector
+      attr_reader :name, :template_path
+
+      DEFAULT_TEMPLATE_PATH = File.expand_path(
+        "../templates/vector_template.yml", __dir__
+      ).freeze
+
+      def initialize(name, template_path: DEFAULT_TEMPLATE_PATH)
+        @name = name
+        @template_path = Pathname(template_path)
+      end
+
+      def add
+        directory.mkpath
+        FileUtils.cp(template_path, config_path)
+      end
+
+      private
+
+      def directory
+        Pathname.pwd.join("vectors")
+      end
+
+      def config_path
+        directory.join("#{name.downcase}.yml")
+      end
+    end
+  end
+end

data/lib/manifold/api/workspace.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Manifold
+  module API
+    # Encapsulates a single manifold.
+    class Workspace
+      attr_reader :name, :template_path, :logger
+
+      DEFAULT_TEMPLATE_PATH = File.expand_path(
+        "../templates/workspace_template.yml", __dir__
+      ).freeze
+
+      def initialize(name, template_path: DEFAULT_TEMPLATE_PATH, logger: Logger.new($stdout))
+        @name = name
+        @template_path = template_path
+        @logger = logger
+        @vector_service = Services::VectorService.new(logger)
+      end
+
+      def self.from_directory(directory, logger: Logger.new($stdout))
+        new(directory.basename.to_s, logger:)
+      end
+
+      def add
+        [tables_directory, routines_directory].each(&:mkpath)
+        FileUtils.cp(template_path, manifold_path)
+      end
+
+      def generate(with_terraform: false)
+        return unless manifold_exists? && any_vectors?
+
+        generate_dimensions
+        generate_terraform if with_terraform
+        logger.info("Generated BigQuery dimensions table schema for workspace '#{name}'.")
+      end
+
+      def tables_directory
+        directory.join("tables")
+      end
+
+      def routines_directory
+        directory.join("routines")
+      end
+
+      def manifold_file
+        return nil unless manifold_exists?
+
+        File.new(manifold_path)
+      end
+
+      def manifold_exists?
+        manifold_path.file?
+      end
+
+      def manifold_path
+        directory.join("manifold.yml")
+      end
+
+      def terraform_main_path
+        directory.join("main.tf.json")
+      end
+
+      private
+
+      def directory
+        Pathname.pwd.join("workspaces", name)
+      end
+
+      def manifold_yaml
+        @manifold_yaml ||= YAML.safe_load_file(manifold_path)
+      end
+
+      def generate_dimensions
+        dimensions_path.write(dimensions_schema_json.concat("\n"))
+      end
+
+      def dimensions_schema
+        [
+          { "type" => "STRING", "name" => "id", "mode" => "REQUIRED" },
+          { "type" => "RECORD", "name" => "dimensions", "mode" => "REQUIRED",
+            "fields" => dimensions_fields }
+        ]
+      end
+
+      def dimensions_fields
+        vectors.filter_map do |vector|
+          logger.info("Loading vector schema for '#{vector}'.")
+          @vector_service.load_vector_schema(vector)
+        end
+      end
+
+      def dimensions_schema_json
+        JSON.pretty_generate(dimensions_schema)
+      end
+
+      def dimensions_path
+        tables_directory.join("dimensions.json")
+      end
+
+      def any_vectors?
+        !(vectors.nil? || vectors.empty?)
+      end
+
+      def vectors
+        manifold_yaml["vectors"]
+      end
+
+      def generate_terraform
+        config = Terraform::WorkspaceConfiguration.new(name)
+        vectors.each do |vector|
+          vector_config = @vector_service.load_vector_config(vector)
+          config.add_vector(vector_config)
+        end
+        config.write(terraform_main_path)
+      end
+    end
+  end
+end

data/lib/manifold/cli.rb

@@ -11,14 +11,12 @@ module Manifold
 
       self.logger = logger
       logger.level = Logger::INFO
-
-      self.bq_service = Services::BigQueryService.new(logger)
     end
 
     desc "init NAME", "Generate a new umbrella project for data management"
     def init(name)
       Manifold::API::Project.create(name)
-      logger.info "Created umbrella project '#{name}' with projects and vectors directories."
+      logger.info "Created umbrella project '#{name}' with workspaces and vectors directories."
     end
 
     desc "vectors SUBCOMMAND ...ARGS", "Manage vectors"
@@ -33,28 +31,28 @@ module Manifold
       end
 
       desc "add VECTOR_NAME", "Add a new vector configuration"
-      def add(name, project: API::Project.new(File.basename(Dir.getwd)))
-        vector = API::Vector.new(name, project: project)
+      def add(name)
+        vector = API::Vector.new(name)
         vector.add
         logger.info "Created vector configuration for '#{name}'."
       end
     }
 
     desc "add WORKSPACE_NAME", "Add a new workspace to a project"
-    def add(name, project: API::Project.new(File.basename(Dir.getwd)))
-      workspace = API::Workspace.new(name, project: project)
+    def add(name)
+      workspace = API::Workspace.new(name)
       workspace.add
       logger.info "Added workspace '#{name}' with tables and routines directories."
     end
 
-    desc "generate PROJECT_NAME SERVICE", "Generate services for a project"
-    def generate(project_name, service)
-      case service
-      when "bq"
-        bq_service.generate_dimensions_schema(project_name)
-      else
-        logger.error("Unsupported service: #{service}")
-      end
+    desc "generate", "Generate BigQuery schema for all workspaces in the project"
+    method_option :tf, type: :boolean, desc: "Generate Terraform configurations"
+    def generate
+      path = Pathname.pwd
+      name = path.basename.to_s
+      project = API::Project.new(name, directory: path, logger:)
+      project.generate(with_terraform: options[:tf])
+      logger.info "Generated BigQuery schema for all workspaces in the project."
     end
   end
 end

data/lib/manifold/services/vector_service.rb

@@ -10,14 +10,23 @@ module Manifold
 
       def load_vector_schema(vector_name)
         path = config_path(vector_name)
-        unless path.file?
-          @logger.error("Vector configuration not found: #{path}")
-          return nil
-        end
-
         config = YAML.safe_load_file(path)
         fields = transform_attributes_to_schema(config["attributes"])
         { "name" => vector_name.downcase, "type" => "RECORD", "fields" => fields }
+      rescue Errno::ENOENT, Errno::EISDIR
+        raise "Vector configuration not found: #{path}"
+      rescue Psych::Exception => e
+        raise "Invalid YAML in vector configuration #{path}: #{e.message}"
+      end
+
+      def load_vector_config(vector_name)
+        path = config_path(vector_name)
+        config = YAML.safe_load_file(path)
+        config.merge("name" => vector_name.downcase)
+      rescue Errno::ENOENT, Errno::EISDIR
+        raise "Vector configuration not found: #{path}"
+      rescue Psych::Exception => e
+        raise "Invalid YAML in vector configuration #{path}: #{e.message}"
       end
 
       private

data/lib/manifold/templates/vector_template.yml

@@ -5,3 +5,7 @@ attributes:
   # id: STRING
   # created_at: TIMESTAMP
   # status: STRING
+
+# Optionally, reference a view specifying how to select vector dimensions
+# merge:
+#   source: lib/views/select_my_vector.sql

data/lib/manifold/terraform/configuration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Manifold
+  module Terraform
+    # Provides a base class for Terraform configuration files.
+    class Configuration
+      def as_json
+        raise NotImplementedError, "#{self.class} must implement #as_json"
+      end
+
+      def write(path)
+        path.write("#{JSON.pretty_generate(as_json)}\n")
+      end
+    end
+  end
+end

data/lib/manifold/terraform/project_configuration.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Manifold
+  module Terraform
+    # Represents a Terraform configuration for a Manifold project.
+    class ProjectConfiguration < Configuration
+      attr_reader :workspaces, :provider_version
+
+      DEFAULT_TERRAFORM_GOOGLE_PROVIDER_VERSION = "6.18.1"
+
+      def initialize(workspaces, provider_version: DEFAULT_TERRAFORM_GOOGLE_PROVIDER_VERSION)
+        super()
+        @workspaces = workspaces
+        @provider_version = provider_version
+      end
+
+      def as_json
+        {
+          "terraform" => terraform_block,
+          "provider" => provider_block,
+          "variable" => variables_block,
+          "module" => workspace_modules
+        }
+      end
+
+      private
+
+      def terraform_block
+        {
+          "required_providers" => {
+            "google" => {
+              "source" => "hashicorp/google",
+              "version" => provider_version
+            }
+          }
+        }
+      end
+
+      def provider_block
+        {
+          "google" => {
+            "project" => "${var.project_id}"
+          }
+        }
+      end
+
+      def variables_block
+        {
+          "project_id" => {
+            "description" => "The GCP project ID where resources will be created",
+            "type" => "string"
+          }
+        }
+      end
+
+      def workspace_modules
+        workspaces.each_with_object({}) do |workspace, modules|
+          modules[workspace.name] = {
+            "source" => "./workspaces/#{workspace.name}",
+            "project_id" => "${var.project_id}"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/manifold/terraform/workspace_configuration.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Manifold
+  module Terraform
+    # Represents a Terraform configuration for a Manifold workspace.
+    class WorkspaceConfiguration < Configuration
+      attr_reader :name
+
+      def initialize(name)
+        super()
+        @name = name
+        @vectors = []
+      end
+
+      def add_vector(vector_config)
+        @vectors << vector_config
+      end
+
+      def as_json
+        {
+          "variable" => variables_block,
+          "resource" => {
+            "google_bigquery_dataset" => dataset_config,
+            "google_bigquery_table" => table_config,
+            "google_bigquery_routine" => routine_config
+          }.compact
+        }
+      end
+
+      private
+
+      def variables_block
+        {
+          "project_id" => {
+            "description" => "The GCP project ID where resources will be created",
+            "type" => "string"
+          }
+        }
+      end
+
+      def dataset_config
+        {
+          name => {
+            "dataset_id" => name,
+            "project" => "${var.project_id}",
+            "location" => "US"
+          }
+        }
+      end
+
+      def table_config
+        {
+          "dimensions" => {
+            "dataset_id" => name,
+            "project" => "${var.project_id}",
+            "table_id" => "Dimensions",
+            "schema" => "${file(\"${path.module}/tables/dimensions.json\")}",
+            "depends_on" => ["google_bigquery_dataset.#{name}"]
+          }
+        }
+      end
+
+      def routine_config
+        return nil if @vectors.empty?
+
+        routines = @vectors.filter_map { |vector| build_routine(vector) }
+        routines.empty? ? nil : routines.to_h
+      end
+
+      def build_routine(vector)
+        return nil unless vector["merge"]&.fetch("source", nil)
+
+        routine_name = "merge_#{vector["name"].downcase}_dimensions"
+        [routine_name, routine_attributes(routine_name, vector)]
+      end
+
+      def routine_attributes(routine_name, vector)
+        {
+          "dataset_id" => name,
+          "project" => "${var.project_id}",
+          "routine_id" => routine_name,
+          "routine_type" => "PROCEDURE",
+          "language" => "SQL",
+          "definition_body" => merge_routine_definition(vector),
+          "depends_on" => ["google_bigquery_dataset.#{name}"]
+        }
+      end
+
+      def merge_routine_definition(vector)
+        source_sql = read_source_sql(vector["merge"]["source"])
+        <<~SQL
+          MERGE #{name}.Dimensions AS TARGET
+          USING (
+            #{source_sql}
+          ) AS source
+          ON source.id = target.id
+          WHEN MATCHED THEN UPDATE SET target.#{vector["name"].downcase} = source.dimensions
+          WHEN NOT MATCHED THEN INSERT ROW;
+        SQL
+      end
+
+      def read_source_sql(source_path)
+        File.read(Pathname.pwd.join(source_path))
+      end
+    end
+  end
+end

data/lib/manifold/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Manifold
-  VERSION = "0.0.7"
+  VERSION = "0.0.9"
 end

data/lib/manifold.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "json"
+require "logger"
 require "pathname"
 require "thor"
 require "yaml"
 
-Dir[File.join(__dir__, "manifold", "**", "*.rb")].sort.each do |file|
+Dir[File.join(__dir__, "manifold", "**", "*.rb")].each do |file|
   require file
 end
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: manifold-cli
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.9
 platform: ruby
 authors:
 - claytongentry
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-11 00:00:00.000000000 Z
+date: 2025-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -24,7 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email:
 - clayton@bustle.com
 executables:
@@ -44,14 +42,16 @@ files:
 - docs/CONTRIBUTING.md
 - lib/manifold.rb
 - lib/manifold/api.rb
+- lib/manifold/api/project.rb
+- lib/manifold/api/vector.rb
+- lib/manifold/api/workspace.rb
 - lib/manifold/cli.rb
-- lib/manifold/project/project.rb
-- lib/manifold/project/vector.rb
-- lib/manifold/project/workspace.rb
-- lib/manifold/services/big_query_service.rb
 - lib/manifold/services/vector_service.rb
 - lib/manifold/templates/vector_template.yml
 - lib/manifold/templates/workspace_template.yml
+- lib/manifold/terraform/configuration.rb
+- lib/manifold/terraform/project_configuration.rb
+- lib/manifold/terraform/workspace_configuration.rb
 - lib/manifold/version.rb
 - sig/manifold.rbs
 homepage: https://github.com/bustle/manifold
@@ -61,7 +61,7 @@ metadata:
   homepage_uri: https://github.com/bustle/manifold
   source_code_uri: https://github.com/bustle/manifold
   changelog_uri: https://github.com/bustle/manifold/CHANGELOG.md
-post_install_message:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -69,15 +69,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A CLI for managing data infrastructures in BigQuery
 test_files: []

data/lib/manifold/project/project.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Manifold
-  module API
-    # Projects API
-    class Project
-      attr_reader :name, :directory
-
-      def initialize(name, directory: Pathname.pwd.join(name))
-        self.name = name
-        self.directory = Pathname(directory)
-      end
-
-      def self.create(name, directory: Pathname.pwd.join(name))
-        new(name, directory: directory).tap do |project|
-          [project.workspaces_directory, project.vectors_directory].each(&:mkpath)
-        end
-      end
-
-      def workspaces_directory
-        directory.join("workspaces")
-      end
-
-      def vectors_directory
-        directory.join("vectors")
-      end
-
-      private
-
-      attr_writer :name, :directory
-    end
-  end
-end

data/lib/manifold/project/vector.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Manifold
-  module API
-    # Describes the entities for whom metrics are calculated.
-    class Vector
-      attr_reader :name, :project, :template_path
-
-      DEFAULT_TEMPLATE_PATH = Pathname.pwd.join(
-        "lib", "manifold", "templates", "vector_template.yml"
-      ).freeze
-
-      def initialize(name, project:, template_path: DEFAULT_TEMPLATE_PATH)
-        self.name = name
-        self.project = project
-        self.template_path = Pathname(template_path)
-      end
-
-      def add
-        directory.mkpath
-        FileUtils.cp(template_path, config_path)
-      end
-
-      private
-
-      attr_writer :name, :project, :template_path
-
-      def directory
-        project.directory.join("vectors")
-      end
-
-      def config_path
-        directory.join("#{name.downcase}.yml")
-      end
-    end
-  end
-end

data/lib/manifold/project/workspace.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Manifold
-  module API
-    # Encapsulates a single manifold.
-    class Workspace
-      attr_reader :name, :project, :template_path
-
-      DEFAULT_TEMPLATE_PATH = Pathname.pwd.join(
-        "lib", "manifold", "templates", "workspace_template.yml"
-      )
-
-      def initialize(name, project:, template_path: DEFAULT_TEMPLATE_PATH)
-        self.name = name
-        self.project = project
-        self.template_path = template_path
-      end
-
-      def add
-        [tables_directory, routines_directory].each(&:mkpath)
-        FileUtils.cp(template_path, manifold_path)
-      end
-
-      def tables_directory
-        project.workspaces_directory.join(name, "tables")
-      end
-
-      def routines_directory
-        project.workspaces_directory.join(name, "routines")
-      end
-
-      def manifold_file
-        return nil unless manifold_exists?
-
-        File.new(manifold_path)
-      end
-
-      def manifold_exists?
-        manifold_path.file?
-      end
-
-      def manifold_path
-        project.workspaces_directory.join(name, "manifold.yml")
-      end
-
-      private
-
-      attr_writer :name, :project, :template_path
-    end
-  end
-end

data/lib/manifold/services/big_query_service.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Manifold
-  module Services
-    # Handles the generation of BigQuery schemas based on project configurations
-    class BigQueryService
-      def initialize(logger)
-        @logger = logger
-        @vector_service = Manifold::Services::VectorService.new(logger)
-      end
-
-      def generate_dimensions_schema(project_name)
-        config_path = Pathname.pwd.join("projects", project_name, "manifold.yml")
-        return unless validate_config_exists(config_path, project_name)
-
-        config = YAML.safe_load_file(config_path)
-
-        fields = config["vectors"].reduce([]) do |list, vector|
-          @logger.info("Loading vector schema for '#{vector}'.")
-          [*@vector_service.load_vector_schema(vector), *list]
-        end
-
-        create_dimensions_file(project_name, fields)
-      end
-
-      private
-
-      def validate_config_exists(config_path, project_name)
-        unless config_path.file?
-          @logger.error("Config file missing for project '#{project_name}'.")
-          return false
-        end
-        true
-      end
-
-      def create_dimensions_file(project_name, fields)
-        tables_directory(project_name).mkpath
-        dimensions = dimensions_schema(fields)
-
-        dimensions_path(project_name).write(dimensions)
-        @logger.info("Generated BigQuery dimensions table schema for '#{project_name}'.")
-      end
-
-      def dimensions_schema(fields)
-        JSON.pretty_generate([
-                               { "type" => "STRING", "name" => "id", "mode" => "REQUIRED" },
-                               { "type" => "RECORD", "name" => "dimensions", "mode" => "REQUIRED",
-                                 "fields" => fields }
-                             ]).concat("\n")
-      end
-
-      def tables_directory(project_name)
-        Pathname.pwd.join("projects", project_name, "bq", "tables")
-      end
-
-      def dimensions_path(project_name)
-        tables_directory(project_name).join("dimensions.json")
-      end
-    end
-  end
-end