moco-ruby 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94fd15c735a242e23f7a1e20dd49408d12dbfbb21f1665ca64bfd85ba3251cae
-  data.tar.gz: 710f5ce6be51b2c363c6d2b3df871d755e5b21e90e9ad53cbb535ac249b46b6f
+  metadata.gz: 5e60f0a59b12881fc99571967ff77dd1ae8c55ff8f3d45cd467bed9e6bf85c5d
+  data.tar.gz: a2070fba649482eb59f4ab96367cc5d8f12b5bfb0f6923bc7e7f6d2c69135566
 SHA512:
-  metadata.gz: 272eede87d5a02636ca02354ea0ef592f0d21662378fb6817b68cc6fa73e66922b43623f6ac5da5c4c76ac3db9c6ebaee12a340fcc9920df93104303f96668fd
-  data.tar.gz: 12f55e014641e51ecf2f666c04bff0a5f330ae68b91cf63e70060b6f85e5fc759eed517854060190651581a7ffba5bfa8345fdd25b8e2e59a96193a32cdece9a
+  metadata.gz: 867202c4431ae5a1d86fe9a8b18451c4cff6465d2119f5e9738d8a1b3018c6b81c726c00860762cf97ad233632df61bc38588ee0cf2d468f9516e36d65d3ed9f
+  data.tar.gz: 5a7cebee47463f888880ae2f9c0fa672e294adb2a0a1abcf3f098cfe241ac35eb84091607c035d36658cf5eb386880f3fc7f2db2abd0c5de8668c9ae72622333

data/Gemfile.lock

@@ -2,8 +2,8 @@ PATH
   remote: .
   specs:
     moco-ruby (1.0.0)
-      activesupport (~> 7.0)
-      faraday (~> 2.9.0)
+      activesupport (>= 7.0)
+      faraday (>= 2.0)
       fuzzy_match (~> 2.1.0)
 
 GEM
@@ -60,7 +60,7 @@ GEM
     rainbow (3.1.1)
     rake (13.2.1)
     regexp_parser (2.10.0)
-    rexml (3.4.1)
+    rexml (3.4.4)
     rubocop (1.75.2)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)

data/README.md

@@ -226,10 +226,20 @@ Usage: sync_activity.rb [options] source_subdomain target_subdomain
         --match-project-threshold VALUE
                                      Fuzzy match threshold for projects (0.0 - 1.0), default 0.8
         --match-task-threshold VALUE Fuzzy match threshold for tasks (0.0 - 1.0), default 0.45
+        --default-task TASK_NAME     Map unmatched tasks to this default task instead of creating new tasks
+    -d, --debug                      Enable debug output
     -h, --help                       Show this message
 ```
 **Example:** `sync_activity.rb --from 2024-04-01 --to 2024-04-10 --dry-run source-instance target-instance`
 
+**Using Default Task Mapping:** If your target account has limited permissions and cannot create tasks, or if you want to consolidate multiple source tasks into a single target task, use the `--default-task` flag:
+
+```bash
+sync_activity.rb --from 2024-04-01 --to 2024-04-10 --default-task "Other" source-instance target-instance
+```
+
+This will map any unmatched source tasks to a task named "Other" in the corresponding target project, avoiding the need to create new tasks.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

data/copy_project.rb

@@ -0,0 +1,337 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "yaml"
+require "fuzzy_match"
+require_relative "lib/moco"
+
+options = {
+  dry_run: false,
+  verbose: false,
+  copy_activities: true
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options] source_instance target_instance project_identifier"
+
+  opts.on("-n", "--dry-run", "Show what would be copied without making changes") do
+    options[:dry_run] = true
+  end
+
+  opts.on("-v", "--verbose", "Enable verbose output") do
+    options[:verbose] = true
+  end
+
+  opts.on("--no-activities", "Skip copying activities (only copy project and tasks)") do
+    options[:copy_activities] = false
+  end
+
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end.parse!
+
+source_instance = ARGV.shift
+target_instance = ARGV.shift
+project_identifier = ARGV.shift
+
+if source_instance.nil? || target_instance.nil? || project_identifier.nil?
+  warn "Error: source_instance, target_instance, and project_identifier are required"
+  warn "Usage: #{$PROGRAM_NAME} [options] source_instance target_instance project_identifier"
+  exit 1
+end
+
+# Load configuration
+config = YAML.load_file("config.yml")
+source_config = config["instances"].fetch(source_instance, nil)
+target_config = config["instances"].fetch(target_instance, nil)
+
+if source_config.nil?
+  warn "Error: Source instance '#{source_instance}' not found in config.yml"
+  exit 1
+end
+
+if target_config.nil?
+  warn "Error: Target instance '#{target_instance}' not found in config.yml"
+  exit 1
+end
+
+# Initialize clients
+puts "Connecting to instances..."
+source_client = MOCO::Client.new(subdomain: source_instance, api_key: source_config["api_key"])
+target_client = MOCO::Client.new(subdomain: target_instance, api_key: target_config["api_key"])
+
+def log(message, verbose: false, options:)
+  return if verbose && !options[:verbose]
+  puts message
+end
+
+def get_id(obj)
+  return nil if obj.nil?
+  return obj[:id] if obj.is_a?(Hash)
+  return obj.id if obj.respond_to?(:id)
+  nil
+end
+
+def find_or_create_customer(source_customer, target_client, options)
+  log("Looking for customer '#{source_customer.name}' in target...", options: options)
+
+  # Try to find the customer by name
+  target_customers = target_client.companies.all
+  target_customer = target_customers.find { |c| c.name == source_customer.name }
+
+  if target_customer
+    log("✅ Found existing customer: #{target_customer.name} (ID: #{target_customer.id})", options: options)
+    return target_customer
+  end
+
+  log("Customer not found, creating new customer...", options: options)
+
+  if options[:dry_run]
+    log("🔍 [DRY RUN] Would create customer: #{source_customer.name}", options: options)
+    return nil
+  end
+
+  # Create the customer
+  customer_attrs = {
+    name: source_customer.name,
+    type: "customer"
+  }
+
+  # Add optional attributes if they exist
+  customer_attrs[:type] = source_customer.type if source_customer.respond_to?(:type) && source_customer.type
+  customer_attrs[:currency] = source_customer.currency if source_customer.respond_to?(:currency) && source_customer.currency
+  customer_attrs[:website] = source_customer.website if source_customer.respond_to?(:website) && source_customer.website
+  customer_attrs[:address] = source_customer.address if source_customer.respond_to?(:address) && source_customer.address
+  customer_attrs[:info] = source_customer.info if source_customer.respond_to?(:info) && source_customer.info
+  customer_attrs[:custom_properties] = source_customer.custom_properties if source_customer.respond_to?(:custom_properties) && source_customer.custom_properties
+  customer_attrs[:labels] = source_customer.labels if source_customer.respond_to?(:labels) && source_customer.labels
+
+  log("Creating customer: #{customer_attrs[:name]}", verbose: true, options: options)
+  new_customer = target_client.companies.create(customer_attrs)
+  log("✅ Created customer: #{new_customer.name} (ID: #{new_customer.id})", options: options)
+
+  new_customer
+end
+
+def copy_tasks(source_project, target_project, target_client, options)
+  log("\nCopying tasks...", options: options)
+  task_mapping = {}
+
+  source_tasks = source_project.tasks
+  log("Found #{source_tasks.count} tasks in source project", options: options)
+
+  source_tasks.each do |source_task|
+    log("  Task: #{source_task.name}", verbose: true, options: options)
+
+    if options[:dry_run]
+      log("  🔍 [DRY RUN] Would create task: #{source_task.name}", options: options)
+      next
+    end
+
+    # Create the task in the target project
+    task_attrs = {
+      name: source_task.name,
+      billable: source_task.billable,
+      active: source_task.active
+    }
+
+    # Add optional attributes if they exist
+    source_task_attrs = source_task.instance_variable_get(:@attributes)
+    task_attrs[:budget] = source_task_attrs[:budget] if source_task_attrs[:budget]
+    task_attrs[:hourly_rate] = source_task_attrs[:hourly_rate] if source_task_attrs[:hourly_rate]
+
+    log("  Creating task: #{task_attrs[:name]}", verbose: true, options: options)
+    # Use the NestedCollectionProxy to create the task
+    task_proxy = MOCO::NestedCollectionProxy.new(target_client, target_project, :tasks, "Task")
+    new_task = task_proxy.create(task_attrs)
+    task_mapping[source_task.id] = new_task
+    log("  ✅ Created task: #{new_task.name} (ID: #{new_task.id})", options: options)
+  end
+
+  task_mapping
+end
+
+def copy_activities(source_project, target_project, task_mapping, source_client, target_client, options)
+  log("\nCopying activities...", options: options)
+
+  # Get all activities for the source project
+  source_activities = source_client.activities.where(project_id: source_project.id).all
+  log("Found #{source_activities.count} activities in source project", options: options)
+
+  created_count = 0
+  skipped_count = 0
+
+  source_activities.each do |source_activity|
+    log("  Activity: #{source_activity.date} - #{source_activity.hours}h - #{source_activity.description}", verbose: true, options: options)
+
+    if options[:dry_run]
+      log("  🔍 [DRY RUN] Would create activity: #{source_activity.date} - #{source_activity.hours}h", options: options)
+      next
+    end
+
+    # Map the task
+    target_task = task_mapping[source_activity.task&.id]
+
+    if source_activity.task && !target_task
+      log("  ⚠️  Skipping activity - task not mapped: #{source_activity.task.name}", options: options)
+      skipped_count += 1
+      next
+    end
+
+    # Create the activity in the target project
+    activity_attrs = {
+      date: source_activity.date,
+      hours: source_activity.hours,
+      description: source_activity.description,
+      project_id: target_project.id,
+      billable: source_activity.billable,
+      tag: source_activity.tag,
+      remote_service: source_activity.remote_service,
+      remote_id: source_activity.id.to_s # Store original ID for reference
+    }
+
+    activity_attrs[:task_id] = target_task.id if target_task
+
+    log("  Creating activity: #{activity_attrs[:date]} - #{activity_attrs[:hours]}h", verbose: true, options: options)
+
+    begin
+      new_activity = target_client.activities.create(activity_attrs)
+      created_count += 1
+      log("  ✅ Created activity: #{new_activity.date} - #{new_activity.hours}h (ID: #{new_activity.id})", verbose: true, options: options)
+    rescue => e
+      log("  ❌ Error creating activity: #{e.message}", options: options)
+      skipped_count += 1
+    end
+  end
+
+  log("\n✅ Created #{created_count} activities", options: options)
+  log("⚠️  Skipped #{skipped_count} activities", options: options) if skipped_count > 0
+end
+
+# Main execution
+begin
+  log("=" * 80, options: options)
+  log("MOCO Project Copy Tool", options: options)
+  log("=" * 80, options: options)
+  log("Source: #{source_instance}", options: options)
+  log("Target: #{target_instance}", options: options)
+  log("Project: #{project_identifier}", options: options)
+  log("Mode: #{options[:dry_run] ? 'DRY RUN' : 'LIVE'}", options: options)
+  log("=" * 80, options: options)
+
+  # Find the source project
+  log("\nFinding source project...", options: options)
+  source_project = source_client.projects.where(identifier: project_identifier).all.first
+
+  if source_project.nil?
+    warn "Error: Project '#{project_identifier}' not found in source instance"
+    exit 1
+  end
+
+  log("✅ Found project: #{source_project.name} (ID: #{source_project.id})", options: options)
+  log("   Identifier: #{source_project.identifier}", verbose: true, options: options)
+  log("   Status: #{source_project.active ? 'Active' : 'Inactive'}", verbose: true, options: options)
+
+  # Get the customer
+  source_customer = source_project.customer
+  if source_customer.nil?
+    warn "Error: Project has no associated customer"
+    exit 1
+  end
+
+  log("   Customer: #{source_customer.name} (ID: #{source_customer.id})", options: options)
+
+  # Find or create the customer in the target
+  target_customer = find_or_create_customer(source_customer, target_client, options)
+
+  if options[:dry_run]
+    log("\n🔍 [DRY RUN] Would create project: #{source_project.name}", options: options)
+    log("   Identifier: #{source_project.identifier}", options: options)
+    log("   Customer: #{source_customer.name}", options: options)
+
+    # Still show what tasks would be copied
+    copy_tasks(source_project, source_project, target_client, options)
+
+    if options[:copy_activities]
+      log("\n🔍 [DRY RUN] Would copy activities...", options: options)
+      source_activities = source_client.activities.where(project_id: source_project.id).all
+      log("   Found #{source_activities.count} activities to copy", options: options)
+    end
+
+    log("\n" + "=" * 80, options: options)
+    log("DRY RUN COMPLETE - No changes made", options: options)
+    log("=" * 80, options: options)
+    exit 0
+  end
+
+  # Create the project in the target
+  log("\nCreating project in target...", options: options)
+
+  # Access attributes directly from the source project
+  source_attrs = source_project.instance_variable_get(:@attributes)
+
+  project_attrs = {
+    name: source_project.name,
+    identifier: source_project.identifier,
+    customer_id: target_customer.id,
+    currency: source_project.currency,
+    billable: source_project.billable,
+    fixed_price: source_attrs[:fixed_price] || false,
+    retainer: source_attrs[:retainer] || false,
+    finish_date: source_attrs[:finish_date],
+    start_date: source_attrs[:start_date]
+  }
+
+  # Get a default user from the target instance as leader
+  # TODO: implement proper user mapping between instances (match by name/email)
+  target_users = target_client.users.all
+  if target_users.empty?
+    raise "No users found in target instance - cannot set project leader"
+  end
+  project_attrs[:leader_id] = target_users.first.id
+  log("Using default leader: #{target_users.first.firstname} #{target_users.first.lastname} (ID: #{target_users.first.id})", verbose: true, options: options)
+
+  # Add optional attributes if they exist
+  project_attrs[:co_leader_id] = get_id(source_attrs[:co_leader]) if source_attrs[:co_leader]
+  project_attrs[:budget] = source_attrs[:budget] if source_attrs[:budget]
+  project_attrs[:budget_monthly] = source_attrs[:budget_monthly] if source_attrs[:budget_monthly]
+  project_attrs[:budget_expenses] = source_attrs[:budget_expenses] if source_attrs[:budget_expenses]
+  project_attrs[:hourly_rate] = source_attrs[:hourly_rate] if source_attrs[:hourly_rate]
+  project_attrs[:custom_properties] = source_attrs[:custom_properties] if source_attrs[:custom_properties]
+  project_attrs[:labels] = source_attrs[:labels] if source_attrs[:labels]
+  project_attrs[:tags] = source_attrs[:tags] if source_attrs[:tags]
+  project_attrs[:info] = source_attrs[:info] if source_attrs[:info]
+  project_attrs[:billing_address] = source_attrs[:billing_address] if source_attrs[:billing_address]
+  project_attrs[:billing_variant] = source_attrs[:billing_variant] if source_attrs[:billing_variant]
+
+  log("Creating project: #{project_attrs[:name]}", verbose: true, options: options)
+  target_project = target_client.projects.create(project_attrs)
+  log("✅ Created project: #{target_project.name} (ID: #{target_project.id})", options: options)
+
+  # Copy tasks
+  task_mapping = copy_tasks(source_project, target_project, target_client, options)
+
+  # Copy activities if requested
+  if options[:copy_activities]
+    copy_activities(source_project, target_project, task_mapping, source_client, target_client, options)
+  else
+    log("\nSkipping activities (--no-activities specified)", options: options)
+  end
+
+  log("\n" + "=" * 80, options: options)
+  log("✅ PROJECT COPY COMPLETE", options: options)
+  log("=" * 80, options: options)
+  log("Source project: #{source_project.name} (#{source_instance})", options: options)
+  log("Target project: #{target_project.name} (#{target_instance})", options: options)
+  log("Target project ID: #{target_project.id}", options: options)
+  log("Target project URL: https://#{target_instance}.mocoapp.com/projects/#{target_project.id}", options: options)
+  log("=" * 80, options: options)
+
+rescue => e
+  warn "\n❌ Error: #{e.message}"
+  warn e.backtrace.join("\n") if options[:verbose]
+  exit 1
+end

data/lib/moco/entities/project.rb

@@ -32,6 +32,14 @@ module MOCO
 
     # Fetches tasks associated with this project.
     def tasks
+      # If tasks are already embedded in the attributes (e.g., from projects.assigned),
+      # return them directly instead of making a new API call
+      embedded_tasks = attributes[:tasks]
+      if embedded_tasks.is_a?(Array) && embedded_tasks.all? { |t| t.is_a?(MOCO::Task) }
+        return embedded_tasks
+      end
+
+      # Otherwise, create a proxy for fetching tasks via API
       # Don't cache the proxy - create a fresh one each time
       # This ensures we get fresh data when tasks are created/updated/deleted
       MOCO::NestedCollectionProxy.new(client, self, :tasks, "Task")

data/lib/moco/sync.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require "fuzzy_match"
 require_relative "client"
 
@@ -17,12 +18,15 @@ module MOCO
       @filters = args.fetch(:filters, {})
       @dry_run = args.fetch(:dry_run, false)
       @debug = args.fetch(:debug, false)
+      @default_task_name = args.fetch(:default_task_name, nil)
 
       @project_mapping = {}
       @task_mapping = {}
+      @default_task_cache = {} # Cache default tasks per project
 
       fetch_assigned_projects
       build_initial_mappings
+      create_missing_tasks_for_activities
     end
 
     # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -420,6 +424,110 @@ module MOCO
       end
     end
 
+    def create_missing_tasks_for_activities
+      # Fetch source activities to see which tasks are actually used
+      source_activity_filters = @filters.fetch(:source, {})
+      source_activities = @source.activities.where(source_activity_filters).all
+
+      # Collect unique task IDs that are used in activities and need syncing
+      tasks_needed = Set.new
+      source_activities.each do |activity|
+        # Only consider activities for mapped projects
+        next unless @project_mapping[activity.project&.id]
+        # Check if task is already mapped
+        next if activity.task.nil?
+        next if @task_mapping[activity.task.id]
+
+        tasks_needed.add(activity.task.id)
+      end
+
+      return if tasks_needed.empty?
+
+      debug_log "Found #{tasks_needed.size} unmapped tasks used in activities"
+
+      # Track tasks that couldn't be created due to permission errors
+      @failed_task_creations ||= []
+      @mapped_to_default ||= []
+
+      # Create missing tasks in target projects
+      tasks_needed.each do |task_id|
+        # Find the source task from source activities
+        source_activity = source_activities.find { |a| a.task&.id == task_id }
+        next unless source_activity
+
+        source_task = source_activity.task
+        source_project_id = source_activity.project.id
+        target_project = @project_mapping[source_project_id]
+
+        # If default task name is provided, try to map to it instead of creating
+        if @default_task_name
+          default_task = find_default_task(target_project)
+          if default_task
+            @task_mapping[source_task.id] = default_task
+            debug_log "  Mapped task '#{source_task.name}' -> default task '#{default_task.name}' (#{default_task.id})"
+            @mapped_to_default << {
+              task_name: source_task.name,
+              project_name: target_project.name,
+              default_task_name: default_task.name
+            }
+            next
+          else
+            warn "  WARNING: Default task '#{@default_task_name}' not found in target project '#{target_project.name}'"
+            warn "           Will attempt to create task '#{source_task.name}' instead"
+          end
+        end
+
+        debug_log "  Creating missing task '#{source_task.name}' in target project #{target_project.id} (#{target_project.name})"
+
+        unless @dry_run
+          begin
+            # Create the task in the target project
+            # Tasks used in activities must be active
+            # Use NestedCollectionProxy to create the task
+            task_proxy = MOCO::NestedCollectionProxy.new(@target, target_project, :tasks, "Task")
+            new_task = task_proxy.create(
+              name: source_task.name,
+              billable: source_task.billable,
+              active: true
+            )
+
+            # Add to mapping
+            @task_mapping[source_task.id] = new_task
+            debug_log "    Created task #{new_task.id} - #{new_task.name}"
+          rescue StandardError => e
+            # Check if this is a permission error
+            if e.message =~ /403|Forbidden|401|Unauthorized|not authorized|permission/i
+              warn "  WARNING: Cannot create task '#{source_task.name}' in target project - insufficient permissions"
+              warn "           Activities using this task will be skipped during sync"
+              @failed_task_creations << {
+                task_name: source_task.name,
+                project_name: target_project.name,
+                project_id: target_project.id
+              }
+            else
+              # Re-raise other errors
+              raise
+            end
+          end
+        else
+          debug_log "    (Dry run - would create task '#{source_task.name}')"
+        end
+      end
+    end
+
+    def find_default_task(target_project)
+      # Return cached result if available
+      return @default_task_cache[target_project.id] if @default_task_cache.key?(target_project.id)
+
+      # Search for the default task in the target project
+      default_task = target_project.tasks.find { |task| task.name == @default_task_name }
+
+      # Cache the result (even if nil)
+      @default_task_cache[target_project.id] = default_task
+
+      default_task
+    end
+
     def match_project(target_project)
       # Create array of search objects manually since we can't call map on EntityCollection
       searchable_projects = []
@@ -436,19 +544,17 @@ module MOCO
     end
 
     def match_task(target_task, source_project)
-      # Get tasks from the source project
+      # Get tasks from the source project (embedded in projects.assigned response)
       tasks = source_project.tasks
 
-      # Create array of search objects manually since we can't rely on Enumerable methods
+      # Only proceed if we have tasks to match against
+      return nil if tasks.empty?
 
-      # Manually iterate through tasks
+      # Create array of search objects for fuzzy matching
       searchable_tasks = tasks.map do |task|
         { original: task, name: task.name }
       end
 
-      # Only proceed if we have tasks to match against
-      return nil if searchable_tasks.empty?
-
       matcher = FuzzyMatch.new(searchable_tasks, read: :name)
       match = matcher.find(target_task.name, threshold: @task_match_threshold)
       match[:original] if match

data/lib/moco/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MOCO
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/moco-ruby.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# This file exists so that `gem 'moco-ruby'` auto-requires correctly.
+# Bundler converts gem names with hyphens to require paths with slashes,
+# so 'moco-ruby' looks for 'moco/ruby'. This shim redirects to the real entry point.
+require_relative "moco"

data/sync_activity.rb

@@ -11,7 +11,8 @@ options = {
   project: nil,
   match_project_threshold: 0.8,
   match_task_threshold: 0.45,
-  debug: false
+  debug: false,
+  default_task: nil
 }
 
 OptionParser.new do |opts|
@@ -52,6 +53,10 @@ OptionParser.new do |opts|
   opts.on("-d", "--debug", "Enable debug output") do
     options[:debug] = true
   end
+
+  opts.on("--default-task TASK_NAME", "Default task name to map unmatched tasks to (avoids creating new tasks)") do |task_name|
+    options[:default_task] = task_name
+  end
 end.parse!
 
 source_instance = ARGV.shift
@@ -82,7 +87,8 @@ syncer = MOCO::Sync.new(
     target: options.slice(:from, :to)
   },
   dry_run: options[:dry_run],
-  debug: options[:debug]
+  debug: options[:debug],
+  default_task_name: options[:default_task]
 )
 
 syncer.source_projects.each do |project|

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: moco-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Teal Bauer
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-08 00:00:00.000000000 Z
+date: 2026-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.9.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.9.0
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: fuzzy_match
   requirement: !ruby/object:Gem::Requirement
@@ -69,7 +69,9 @@ files:
 - README.md
 - Rakefile
 - config.yml.sample
+- copy_project.rb
 - examples/v2_api_example.rb
+- lib/moco-ruby.rb
 - lib/moco.rb
 - lib/moco/client.rb
 - lib/moco/collection_proxy.rb
@@ -94,7 +96,6 @@ files:
 - lib/moco/nested_collection_proxy.rb
 - lib/moco/sync.rb
 - lib/moco/version.rb
-- moco.gemspec
 - mocurl.rb
 - sync_activity.rb
 homepage: https://github.com/starsong-consulting/moco-ruby

data/moco.gemspec

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/moco/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "moco-ruby"
-  spec.version = MOCO::VERSION
-  spec.authors = ["Teal Bauer"]
-  spec.email = ["rubygems@teal.is"]
-
-  spec.summary = "A Ruby Gem to interact with the MOCO (mocoapp.com) API."
-  spec.homepage = "https://github.com/starsong-consulting/moco-ruby"
-  spec.required_ruby_version = ">= 3.2.0"
-  spec.license = "Apache-2.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/starsong-consulting/moco-ruby"
-  spec.metadata["changelog_uri"] = "https://github.com/starsong-consulting/moco-ruby/blob/main/CHANGELOG.md"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "activesupport", "~> 7.0"
-  spec.add_dependency "faraday", "~> 2.9.0"
-  spec.add_dependency "fuzzy_match", "~> 2.1.0"
-
-  spec.metadata["rubygems_mfa_required"] = "true"
-end