moco-ruby 1.0.0.alpha → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cda64cf9e66f0409e61b5fc1b0ad5b0bc440acfe3e1202d9baab08c87c21d6b1
-  data.tar.gz: cc6e0952ee9c89a4ac73f08c0093f1723563346f8bd2cfec27901faeed943ae8
+  metadata.gz: 94fd15c735a242e23f7a1e20dd49408d12dbfbb21f1665ca64bfd85ba3251cae
+  data.tar.gz: 710f5ce6be51b2c363c6d2b3df871d755e5b21e90e9ad53cbb535ac249b46b6f
 SHA512:
-  metadata.gz: f3bc2329dca452e3efbecc83b015532f5f32102d4e26a8bd787e036df3ac2384ac6f3ae95b0a67999cb9858197357cc0ee5beb744ad07168268e3067d6f774e7
-  data.tar.gz: 8189ab5b3015b78d1c93c0231497283e1d1d89ef1673c02d0762f161fcb6d277e4350f052fe799b80993b14cd645db0290ee0379c9455c840abe3646afa54415
+  metadata.gz: 272eede87d5a02636ca02354ea0ef592f0d21662378fb6817b68cc6fa73e66922b43623f6ac5da5c4c76ac3db9c6ebaee12a340fcc9920df93104303f96668fd
+  data.tar.gz: 12f55e014641e51ecf2f666c04bff0a5f330ae68b91cf63e70060b6f85e5fc759eed517854060190651581a7ffba5bfa8345fdd25b8e2e59a96193a32cdece9a

data/CHANGELOG.md

@@ -1,7 +1,43 @@
-# Changelog
+# # Changelog
 
 ## [Unreleased]
 
+## [1.0.0] - 2025-10-08
+
+### Fixed
+- Fixed Project `leader` and `co_leader` associations to return User objects instead of Hashes
+- Fixed Expense associations to use proper `association()` method for embedded objects
+- Fixed nested resource proxy caching issue - tasks and expenses now always return fresh data
+- Fixed `NestedCollectionProxy` path construction for expenses (was double-prefixing with "projects/")
+- Fixed `entity_path` warnings by converting instance methods to class methods in Holiday and WebHook classes
+- Fixed embedded entity conversion for leader, co_leader, and user associations in BaseEntity
+
+### Added
+- Added comprehensive test suite using test-unit framework:
+  - `test/test_comprehensive.rb` - 27 integration tests covering all CRUD operations
+  - `test/test_holidays_expenses.rb` - 9 tests for holidays and expenses (nested resources)
+  - `test/test_v2_api.rb` - 4 unit tests with mocked API responses
+  - `test/test_helper.rb` - Shared test configuration
+- Added `Project#expenses` method for nested expense access
+- Added proper entity type mappings for `:leader`, `:co_leader`, and `:user` in BaseEntity
+- Added dotenv gem as development dependency for test environment configuration
+
+### Changed
+- Moved all `require_relative` statements out of methods and into file-level requires
+- Improved load order in `lib/moco.rb` - core classes now load before entities
+- Updated `Expense` entity to use `association()` method for project and user relationships
+- Refactored nested resource access in Project class to return fresh proxies instead of cached ones
+- Enhanced `NestedCollectionProxy` to properly handle nested resource paths without double-prefixing
+
+### Removed
+- Removed manual test scripts (converted to proper test-unit tests)
+
+## [1.0.0.beta] - 2025-04-10
+
+### Fixed
+- Fixed activity synchronization to properly identify existing activities in target system
+- Added remote_id accessor to Activity class to prevent duplicate activity creation
+
 ## [1.0.0.alpha] - 2025-04-10
 
 ### Added
@@ -10,7 +46,7 @@
   - Supports proper path construction for nested API endpoints
   - Implements `destroy_all` method for bulk deletion of nested resources
 
-## [1.0.0] - 2025-04-10
+## [1.0.0.alpha-initial] - 2025-04-10
 
 ### Added
 - Implemented ActiveRecord-style query interface (`where`, `find`, `find_by`, `first`, `all`, `each`) via `CollectionProxy`.
@@ -89,9 +125,11 @@
 ## [0.1.0] - 2024-02-27
 - Initial release
 
-[Unreleased]: https://github.com/starsong-consulting/moco-ruby/compare/v1.0.0.alpha...HEAD
-[1.0.0.alpha]: https://github.com/starsong-consulting/moco-ruby/compare/v1.0.0...v1.0.0.alpha
-[1.0.0]: https://github.com/starsong-consulting/moco-ruby/compare/v0.1.2...v1.0.0
+[Unreleased]: https://github.com/starsong-consulting/moco-ruby/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/starsong-consulting/moco-ruby/compare/v1.0.0.beta...v1.0.0
+[1.0.0.beta]: https://github.com/starsong-consulting/moco-ruby/compare/v1.0.0.alpha...v1.0.0.beta
+[1.0.0.alpha]: https://github.com/starsong-consulting/moco-ruby/compare/v1.0.0.alpha-initial...v1.0.0.alpha
+[1.0.0.alpha-initial]: https://github.com/starsong-consulting/moco-ruby/compare/v0.1.2...v1.0.0.alpha-initial
 [0.1.2]: https://github.com/starsong-consulting/moco-ruby/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/starsong-consulting/moco-ruby/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/starsong-consulting/moco-ruby/releases/tag/v0.1.0

data/Gemfile

@@ -8,3 +8,4 @@ gem "rake", "~> 13.0"
 gem "rubocop", "~> 1.21"
 gem "test-unit", "~> 3.5"
 gem "webmock", "~> 3.18"
+gem "dotenv", "~> 2.8"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    moco-ruby (1.0.0.alpha)
+    moco-ruby (1.0.0)
       activesupport (~> 7.0)
       faraday (~> 2.9.0)
       fuzzy_match (~> 2.1.0)
@@ -32,6 +32,7 @@ GEM
     crack (1.0.0)
       bigdecimal
       rexml
+    dotenv (2.8.1)
     drb (2.2.1)
     faraday (2.9.2)
       faraday-net_http (>= 2.0, < 3.2)
@@ -94,6 +95,7 @@ PLATFORMS
   arm64-darwin-23
 
 DEPENDENCIES
+  dotenv (~> 2.8)
   moco-ruby!
   rake (~> 13.0)
   rubocop (~> 1.21)

data/README.md

@@ -232,9 +232,35 @@ Usage: sync_activity.rb [options] source_subdomain target_subdomain
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+### Running Tests
+
+The gem includes a comprehensive test suite with both unit tests (mocked) and integration tests (live API):
+
+```bash
+# Run all tests
+ruby test/test_v2_api.rb              # Unit tests (mocked, fast)
+ruby test/test_comprehensive.rb       # Integration tests (requires .env)
+ruby test/test_holidays_expenses.rb   # Holidays & Expenses tests (requires .env)
+
+# Or run individually
+ruby test/test_v2_api.rb
+```
+
+For integration tests, create a `.env` file with your test instance credentials:
+```
+MOCO_API_TEST_SUBDOMAIN=your-test-subdomain
+MOCO_API_TEST_API_KEY=your-test-api-key
+```
+
+**Note:** The MOCO API has rate limits (120 requests per 2 minutes on standard plans). Integration tests make real API calls.
+
+### Installation
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+To release a new version, update the version number in `version.rb`, update the `CHANGELOG.md`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/lib/moco/client.rb

@@ -6,8 +6,8 @@ module MOCO
   class Client
     attr_reader :connection
 
-    def initialize(subdomain:, api_key:)
-      @connection = Connection.new(self, subdomain, api_key)
+    def initialize(subdomain:, api_key:, debug: false)
+      @connection = Connection.new(self, subdomain, api_key, debug: debug)
       @collections = {}
     end
 

data/lib/moco/collection_proxy.rb

@@ -54,6 +54,13 @@ module MOCO
       self
     end
 
+    # Modifies the base path to fetch assigned resources. Returns self.
+    def assigned
+      # Ensure this is only called once or handle idempotency if needed
+      @base_path += "/assigned"
+      self
+    end
+
     # --- Methods Triggering API Call ---
 
     # Fetches all records matching the current filters.
@@ -130,6 +137,9 @@ module MOCO
       # MOCO API might use 'per_page' instead of 'limit' for pagination control
       # Adjust if necessary based on API docs. Assuming 'limit' works for now.
 
+      # Filter out nil values before sending to avoid empty params like ?from&to=
+      query_params.compact!
+
       response = client.get(@base_path, query_params)
       @records = wrap_response(response) # wrap_response should return an Array here
       @loaded = true

data/lib/moco/connection.rb

@@ -7,12 +7,13 @@ module MOCO
   # Handles HTTP communication with the MOCO API
   # Responsible for building API requests and converting responses to entity objects
   class Connection
-    attr_reader :client, :subdomain, :api_key
+    attr_reader :client, :subdomain, :api_key, :debug
 
-    def initialize(client, subdomain, api_key)
+    def initialize(client, subdomain, api_key, debug: false)
       @client = client
       @subdomain = subdomain
       @api_key = api_key
+      @debug = debug
       @conn = Faraday.new do |f|
         f.request :json
         f.response :json
@@ -25,6 +26,11 @@ module MOCO
     # These methods send the request and return the raw parsed JSON response body.
     %w[get post put patch delete].each do |http_method|
       define_method(http_method) do |path, params = {}|
+        # Log URL if debug is enabled
+        if @debug
+          full_url = @conn.build_url(path, params).to_s
+          warn "[DEBUG] Fetching URL: #{http_method.upcase} #{full_url}"
+        end
         response = @conn.send(http_method, path, params)
 
         # Raise an error for non-successful responses

data/lib/moco/entities/activity.rb

@@ -89,8 +89,13 @@ module MOCO
                   end
     end
 
+    # Access the remote_id attribute
+    def remote_id
+      attributes[:remote_id]
+    end
+
     def to_s
-      "#{date} - #{hours}h - #{project&.name} - #{task&.name} - #{description}"
+      "#{attributes[:date]} - #{attributes[:hours]}h - #{project&.name} - #{task&.name} - #{attributes[:description]}"
     end
   end
 end

data/lib/moco/entities/base_entity.rb

@@ -29,6 +29,11 @@ module MOCO
       define_attribute_methods
     end
 
+    # Provides a basic string representation (can be overridden by subclasses).
+    def to_s
+      "#{self.class.name.split("::").last} ##{id}"
+    end
+
     # Returns the entity's ID.
     def id
       attributes[:id] || attributes["id"]
@@ -185,9 +190,11 @@ module MOCO
       # Return cached collection if available
       return @_association_cache[association_name] if @_association_cache.key?(association_name)
 
-      # If the association data is already in attributes and is an array of entities, use it directly
+      # If the association data is already in attributes and is an array of entities
+      # AND this is NOT a nested resource, use it directly
+      # For nested resources, we always create a proxy to ensure CRUD operations work
       association_data = attributes[association_name]
-      if association_data.is_a?(Array) && association_data.all? { |item| item.is_a?(MOCO::BaseEntity) }
+      if !nested && association_data.is_a?(Array) && association_data.all? { |item| item.is_a?(MOCO::BaseEntity) }
         return @_association_cache[association_name] = association_data
       end
 
@@ -201,7 +208,6 @@ module MOCO
       # Check if this is a nested resource
       if nested
         # For nested resources, create a NestedCollectionProxy
-        require_relative "../nested_collection_proxy"
         @_association_cache[association_name] = MOCO::NestedCollectionProxy.new(
           client,
           self,
@@ -273,9 +279,12 @@ module MOCO
 
       # Infer type from the key_hint if :type attribute is missing
       if type_name.nil? && key_hint
-        # Special case: map :customer key to Company class
-        type_name = if key_hint == :customer
+        # Special cases: map certain keys to specific entity classes
+        type_name = case key_hint
+                    when :customer
                       "Company"
+                    when :leader, :co_leader, :user
+                      "User"
                     else
                       # General case: singularize the key hint (e.g., :tasks -> "task")
                       ActiveSupport::Inflector.singularize(key_hint.to_s)

data/lib/moco/entities/expense.rb

@@ -4,6 +4,12 @@ module MOCO
   # Represents a MOCO expense
   # Provides methods for expense-specific operations and associations
   class Expense < BaseEntity
+    # Override entity_path to use the global expenses endpoint
+    # Note: Expenses can also be accessed via projects/{id}/expenses
+    def self.entity_path
+      "projects/expenses"
+    end
+
     # Class methods for bulk operations
     def self.disregard(client, expense_ids:)
       client.post("projects/expenses/disregard", { expense_ids: })
@@ -15,11 +21,13 @@ module MOCO
 
     # Associations
     def project
-      @project ||= client.projects.find(project_id) if project_id
+      # Use the association method which handles embedded objects
+      association(:project, "Project")
     end
 
     def user
-      @user ||= client.users.find(user_id) if user_id
+      # Use the association method which handles embedded objects
+      association(:user, "User")
     end
 
     def to_s

data/lib/moco/entities/holiday.rb

@@ -5,7 +5,7 @@ module MOCO
   # Provides methods for holiday-specific associations
   class Holiday < BaseEntity
     # Override entity_path to match API path
-    def entity_path
+    def self.entity_path
       "users/holidays"
     end
 

data/lib/moco/entities/project.rb

@@ -7,29 +7,38 @@ module MOCO
       association(:customer, "Company")
     end
 
+    def leader
+      # Use the association method to fetch the leader
+      association(:leader, "User")
+    end
+
+    def co_leader
+      # Use the association method to fetch the co_leader
+      association(:co_leader, "User")
+    end
+
     # Fetches activities associated with this project.
     def activities
       # Use the has_many method to fetch activities
       has_many(:activities)
     end
 
+    # Fetches expenses associated with this project.
+    def expenses
+      # Don't cache the proxy - create a fresh one each time
+      # This ensures we get fresh data when expenses are created/updated/deleted
+      MOCO::NestedCollectionProxy.new(client, self, :expenses, "Expense")
+    end
+
     # Fetches tasks associated with this project.
     def tasks
-      # Check if tasks are already loaded in attributes
-      if attributes[:tasks].is_a?(Array) && attributes[:tasks].all? { |t| t.is_a?(MOCO::Task) }
-        # If tasks are already loaded, create a NestedCollectionProxy with the loaded tasks
-        @_tasks_proxy ||= begin
-          require_relative "../nested_collection_proxy"
-          proxy = MOCO::NestedCollectionProxy.new(client, self, :tasks, "Task")
-          # We need to manually set the loaded records since we already have them
-          proxy.instance_variable_set(:@records, attributes[:tasks])
-          proxy.instance_variable_set(:@loaded, true)
-          proxy
-        end
-      else
-        # Otherwise, use has_many with nested=true
-        has_many(:tasks, nil, nil, true)
-      end
+      # 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")
+    end
+
+    def to_s
+      "Project #{identifier} \"#{name}\" (#{id})"
     end
 
     def active?

data/lib/moco/entities/web_hook.rb

@@ -5,7 +5,7 @@ module MOCO
   # Provides methods for webhook-specific operations
   class WebHook < BaseEntity
     # Override entity_path to match API path
-    def entity_path
+    def self.entity_path
       "account/web_hooks"
     end
 

data/lib/moco/entity_collection.rb

@@ -14,8 +14,8 @@ module MOCO
       @entity_class_name = entity_class_name
     end
 
-    def all(params = {})
-      collection.all(params)
+    def all
+      collection.all
     end
 
     def find(id)
@@ -31,7 +31,7 @@ module MOCO
     end
 
     def each(&)
-      all.each(&)
+      collection.each(&)
     end
 
     def first

data/lib/moco/nested_collection_proxy.rb

@@ -12,9 +12,12 @@ module MOCO
     end
 
     # Override determine_base_path to include the parent's path
+    # For nested resources, we ignore any custom entity_path and just use simple pluralization
     def determine_base_path(path_or_entity_name)
       parent_type = ActiveSupport::Inflector.underscore(parent.class.name.split("::").last)
-      "#{parent_type.pluralize}/#{parent.id}/#{super}"
+      # Use simple tableized name, not entity_path (which might include 'projects/' prefix)
+      nested_path = ActiveSupport::Inflector.tableize(path_or_entity_name.to_s)
+      "#{parent_type.pluralize}/#{parent.id}/#{nested_path}"
     end
 
     # Create a new entity in this nested collection

data/lib/moco/sync.rb

@@ -7,7 +7,7 @@ module MOCO
   # Match and map projects and tasks between MOCO instances and sync activities
   class Sync
     attr_reader :project_mapping, :task_mapping, :source_projects, :target_projects
-    attr_accessor :project_match_threshold, :task_match_threshold, :dry_run
+    attr_accessor :project_match_threshold, :task_match_threshold, :dry_run, :debug
 
     def initialize(source_client, target_client, **args)
       @source = source_client
@@ -16,6 +16,7 @@ module MOCO
       @task_match_threshold = args.fetch(:task_match_threshold, 0.45)
       @filters = args.fetch(:filters, {})
       @dry_run = args.fetch(:dry_run, false)
+      @debug = args.fetch(:debug, false)
 
       @project_mapping = {}
       @task_mapping = {}
@@ -28,77 +29,159 @@ module MOCO
     def sync(&callbacks)
       results = []
 
-      source_activities_r = @source.activities.all(@filters.fetch(:source, {}))
-      target_activities_r = @target.activities.all(@filters.fetch(:target, {}))
+      source_activity_filters = @filters.fetch(:source, {})
+      source_activities_r = @source.activities.where(source_activity_filters).all
+      debug_log "Fetched #{source_activities_r.size} source activities"
+
+      # Log source activities for debugging
+      debug_log "Source activities:"
+      source_activities_r.each do |activity|
+        debug_log "  Source Activity: #{activity.id}, Date: #{activity.date}, Project: #{activity.project&.id} (#{activity.project&.name}), Task: #{activity.task&.id} (#{activity.task&.name}), Hours: #{activity.hours}, Description: #{activity.description}, Remote ID: #{activity.remote_id}"
+
+        # Also log the expected target activity for each source activity
+        begin
+          expected = get_expected_target_activity(activity)
+          if expected
+            project_id = expected.project&.id rescue "N/A"
+            task_id = expected.task&.id rescue "N/A"
+            remote_id = expected.instance_variable_get(:@attributes)[:remote_id] rescue "N/A"
+            debug_log "    Expected Target: Project: #{project_id}, Task: #{task_id}, Remote ID: #{remote_id}"
+          end
+        rescue => e
+          debug_log "    Error getting expected target: #{e.message}"
+        end
+      end
 
+      target_activity_filters = @filters.fetch(:target, {})
+      target_activities_r = @target.activities.where(target_activity_filters).all
+      debug_log "Fetched #{target_activities_r.size} target activities"
+
+      # Log target activities for debugging
+      debug_log "Target activities:"
+      target_activities_r.each do |activity|
+        debug_log "  Target Activity: #{activity.id}, Date: #{activity.date}, Project: #{activity.project&.id} (#{activity.project&.name}), Task: #{activity.task&.id} (#{activity.task&.name}), Hours: #{activity.hours}, Description: #{activity.description}, Remote ID: #{activity.remote_id}"
+      end
+
+      # Group activities by date and then by project_id for consistent lookups
       source_activities_grouped = source_activities_r.group_by(&:date).transform_values do |activities|
-        activities.group_by(&:project)
+        activities.group_by { |a| a.project&.id } # Group by project ID
       end
       target_activities_grouped = target_activities_r.group_by(&:date).transform_values do |activities|
-        activities.group_by(&:project)
+        activities.group_by { |a| a.project&.id } # Group by project ID
       end
 
       used_source_activities = []
       used_target_activities = []
 
-      source_activities_grouped.each do |date, activities_by_project|
-        activities_by_project.each do |project, source_activities|
-          target_activities = target_activities_grouped.fetch(date, {}).fetch(@project_mapping[project.id], [])
-          next if source_activities.empty? || target_activities.empty?
+      debug_log "Starting main sync loop..."
+      source_activities_grouped.each do |date, activities_by_project_id|
+        debug_log "Processing date: #{date}"
+        activities_by_project_id.each do |source_project_id, source_activities|
+          debug_log "  Processing source project ID: #{source_project_id} (#{source_activities.count} activities)"
+          # Find the corresponding target project ID using the mapping
+          target_project_object = @project_mapping[source_project_id]
+          unless target_project_object
+            debug_log "    Skipping - Source project ID #{source_project_id} not mapped."
+            next
+          end
+
+          target_project_id = target_project_object.id
+          # Fetch target activities using the target project ID
+          target_activities = target_activities_grouped.fetch(date, {}).fetch(target_project_id, [])
+          debug_log "    Found #{target_activities.count} target activities for target project ID: #{target_project_id}"
+
+          if source_activities.empty? || target_activities.empty?
+            debug_log "    Skipping - No source or target activities for this date/project pair."
+            next
+          end
 
           matches = calculate_matches(source_activities, target_activities)
+          debug_log "    Calculated #{matches.count} potential matches."
           matches.sort_by! { |match| -match[:score] }
 
+          debug_log "    Entering matches loop..."
           matches.each do |match|
             source_activity, target_activity = match[:activity]
             score = match[:score]
+            debug_log "      Match Pair: Score=#{score}, Source=#{source_activity.id}, Target=#{target_activity.id}"
 
-            next if used_source_activities.include?(source_activity) || used_target_activities.include?(target_activity)
+            if used_source_activities.include?(source_activity) || used_target_activities.include?(target_activity)
+              debug_log "        Skipping match pair - already used: Source used=#{used_source_activities.include?(source_activity)}, Target used=#{used_target_activities.include?(target_activity)}"
+              next
+            end
 
-            best_score = score
+            best_score = score # Since we sorted, this is the best score for this unused pair
             best_match = target_activity
             expected_target_activity = get_expected_target_activity(source_activity)
+            debug_log "        Processing best score #{best_score} for Source=#{source_activity.id}"
 
             case best_score
             when 100
+              debug_log "          Case 100: Equal"
               # 100 - perfect match found, nothing needs doing
               callbacks&.call(:equal, source_activity, expected_target_activity)
+              # Mark both as used
+              debug_log "            Marking Source=#{source_activity.id} and Target=#{target_activity.id} as used."
+              used_source_activities << source_activity
+              used_target_activities << target_activity
             when 60...100
+              debug_log "          Case 60-99: Update"
               # >=60 <100 - match with some differences
               expected_target_activity.to_h.except(:id, :user, :customer).each do |k, v|
+                debug_log "            Updating attribute #{k} on Target=#{target_activity.id}"
                 best_match.send("#{k}=", v)
               end
               callbacks&.call(:update, source_activity, best_match)
               unless @dry_run
-                results << @target.activities.update(best_match)
+                debug_log "            Executing API update for Target=#{target_activity.id}"
+                results << @target.activities.update(best_match.id, best_match.attributes) # Pass ID and attributes
                 callbacks&.call(:updated, source_activity, best_match, results.last)
               end
+              # Mark both as used
+              debug_log "            Marking Source=#{source_activity.id} and Target=#{target_activity.id} as used."
+              used_source_activities << source_activity
+              used_target_activities << target_activity
             when 0...60
-              # <60 - no good match found, create new entry
-              callbacks&.call(:create, source_activity, expected_target_activity)
-              unless @dry_run
-                results << @target.activities.create(expected_target_activity)
-                callbacks&.call(:created, source_activity, best_match, results.last)
-              end
+              debug_log "          Case 0-59: Low score, doing nothing for this pair."
+              # <60 - Low score for this specific pair. Do nothing here.
+              # Creation is handled later if source_activity remains unused.
+              nil # Explicitly do nothing
             end
-
-            used_source_activities << source_activity
-            used_target_activities << target_activity
+            # Only mark activities as used if score >= 60 (handled within the case branches above)
           end
+          debug_log "    Finished matches loop."
         end
+        debug_log "  Finished processing project IDs for date #{date}."
       end
+      debug_log "Finished main sync loop."
 
+      # Second loop: Create source activities that were never used (i.e., had no match >= 60)
+      debug_log "Starting creation loop..."
       source_activities_r.each do |source_activity|
-        next if used_source_activities.include?(source_activity)
-        next unless @project_mapping[source_activity.project.id]
+        if used_source_activities.include?(source_activity)
+          debug_log "  Skipping creation for Source=#{source_activity.id} - already used."
+          next
+        end
+        # Use safe navigation in case project is nil
+        source_project_id = source_activity.project&.id
+        unless @project_mapping[source_project_id]
+          debug_log "  Skipping creation for Source=#{source_activity.id} - project #{source_project_id} not mapped."
+          next
+        end
 
+        debug_log "  Processing creation for Source=#{source_activity.id}"
         expected_target_activity = get_expected_target_activity(source_activity)
         callbacks&.call(:create, source_activity, expected_target_activity)
-        unless @dry_run
-          results << @target.activities.create(expected_target_activity)
-          callbacks&.call(:created, source_activity, expected_target_activity, results.last)
-        end
+        next if @dry_run
+
+        debug_log "    Executing API create."
+        # Pass attributes hash to create
+        created_activity = @target.activities.create(expected_target_activity.attributes)
+        results << created_activity
+        # Pass the actual created activity object to the callback
+        callbacks&.call(:created, source_activity, created_activity, results.last)
       end
+      debug_log "Finished creation loop."
 
       results
     end
@@ -106,21 +189,54 @@ module MOCO
 
     private
 
+    def debug_log(message)
+      warn "[SYNC DEBUG] #{message}" if @debug
+    end
+
     def get_expected_target_activity(source_activity)
-      source_activity.dup.tap do |a|
-        a.task = @task_mapping[source_activity.task.id]
-        a.project = @project_mapping[source_activity.project.id]
-      end
+      # Create a duplicate of the source activity
+      new_activity = source_activity.dup
+
+      # Get the attributes hash
+      attrs = new_activity.instance_variable_get(:@attributes)
+
+      # Store the mapped task and project objects for reference
+      mapped_task = @task_mapping[source_activity.task&.id]
+      mapped_project = @project_mapping[source_activity.project&.id]
+
+      # Set the task_id and project_id attributes instead of the full objects
+      attrs[:task_id] = mapped_task.id if mapped_task
+      attrs[:project_id] = mapped_project.id if mapped_project
+
+      # Set remote_id to the source activity ID for future matching
+      attrs[:remote_id] = source_activity.id.to_s
+
+      # Remove the full objects from the attributes hash
+      attrs.delete(:task)
+      attrs.delete(:project)
+
+      # Return the modified activity
+      new_activity
     end
 
     def calculate_matches(source_activities, target_activities)
       matches = []
+      
       source_activities.each do |source_activity|
         target_activities.each do |target_activity|
-          score = score_activity_match(get_expected_target_activity(source_activity), target_activity)
-          matches << { activity: [source_activity, target_activity], score: }
+          # First check if this is a previously synced activity by comparing IDs directly
+          if target_activity.respond_to?(:remote_id) && 
+             target_activity.remote_id.to_s == source_activity.id.to_s
+            debug_log "Direct match found: target.remote_id=#{target_activity.remote_id} matches source.id=#{source_activity.id}" if @debug
+            matches << { activity: [source_activity, target_activity], score: 100 }
+          else
+            # If no direct match, use the regular scoring method
+            score = score_activity_match(get_expected_target_activity(source_activity), target_activity)
+            matches << { activity: [source_activity, target_activity], score: }
+          end
         end
       end
+      
       matches
     end
 
@@ -132,45 +248,145 @@ module MOCO
       [0.0, score].max
     end
 
-    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
     def score_activity_match(a, b)
+      # Must be same project
       return 0 if a.project != b.project
 
+      # Check for exact ID match (for activities that were previously synced)
+      # This is the most important check and overrides all others
+      if a.id.to_s == b.remote_id.to_s || b.id.to_s == a.remote_id.to_s
+        debug_log "Found exact ID match between #{a.id} and #{b.id}" if @debug
+        return 100
+      end
+
+      # Check for exact ID match in remote_id field
+      if a.remote_id.to_s == b.id.to_s || b.remote_id.to_s == a.id.to_s
+        debug_log "Found exact ID match in remote_id: a.remote_id=#{a.remote_id}, b.id=#{b.id}" if @debug
+        return 100
+      end
+
+      # Additional check for remote_id in attributes hash
+      begin
+        a_remote_id = a.instance_variable_get(:@attributes)[:remote_id].to_s rescue nil
+        b_remote_id = b.instance_variable_get(:@attributes)[:remote_id].to_s rescue nil
+        
+        if (a_remote_id && !a_remote_id.empty? && a_remote_id == b.id.to_s) || 
+           (b_remote_id && !b_remote_id.empty? && b_remote_id == a.id.to_s)
+          debug_log "Found exact ID match in attributes hash: a.attributes[:remote_id]=#{a_remote_id}, b.id=#{b.id}" if @debug
+          return 100
+        end
+      rescue => e
+        debug_log "Error checking remote_id in attributes: #{e.message}" if @debug
+      end
+
+      # Date comparison - must be same date
+      # Convert to string for comparison to handle different date object types
+      # and normalize format to YYYY-MM-DD
+      debug_log "Raw dates: a.date=#{a.date.inspect} (#{a.date.class}), b.date=#{b.date.inspect} (#{b.date.class})" if @debug
+
+      # Normalize dates to YYYY-MM-DD format
+      a_date = normalize_date(a.date)
+      b_date = normalize_date(b.date)
+
+      debug_log "Normalized dates: a_date=#{a_date}, b_date=#{b_date}" if @debug
+
+      if a_date != b_date
+        debug_log "Date mismatch: #{a_date} vs #{b_date}" if @debug
+        return 0
+      end
+
       score = 0
-      # (mapped) task is the same as the source task
-      score += 20 if a.task == b.task
-      # description fuzzy match score (0.0 .. 1.0)
-      _, description_match_score = FuzzyMatch.new([a.description]).find_with_score(b.description)
-      score += (description_match_score * 40.0).to_i if description_match_score
-      # differences in time tracked are weighted by sqrt of diff clamped to 7h
-      # i.e. smaller differences are worth higher scores; 1.75h diff = 0.5 score * 40
-      score += (clamped_factored_diff_score(a.hours, b.hours) * 40.0).to_i
+
+      # Task matching is important (30 points)
+      if a.task&.id == b.task&.id
+        score += 30
+        debug_log "Task match: +30 points" if @debug
+      end
+
+      # Description matching (up to 30 points)
+      if a.description.to_s.strip.empty? && b.description.to_s.strip.empty?
+        # Both empty descriptions - consider it a match for this attribute
+        score += 30
+        debug_log "Empty description match: +30 points" if @debug
+      else
+        # Use fuzzy matching for non-empty descriptions
+        _, description_match_score = FuzzyMatch.new([a.description.to_s]).find_with_score(b.description.to_s)
+        if description_match_score
+          desc_points = (description_match_score * 30.0).to_i
+          score += desc_points
+          debug_log "Description match (#{description_match_score}): +#{desc_points} points" if @debug
+        end
+      end
+
+      # Hours matching (up to 40 points)
+      # Exact hour match gets full points
+      if a.hours == b.hours
+        score += 40
+        debug_log "Exact hours match: +40 points" if @debug
+      else
+        # Otherwise use the clamped difference score
+        hours_points = (clamped_factored_diff_score(a.hours, b.hours) * 40.0).to_i
+        score += hours_points
+        debug_log "Hours similarity (#{a.hours} vs #{b.hours}): +#{hours_points} points" if @debug
+      end
+
+      debug_log "Final score for #{a.id} vs #{b.id}: #{score}" if @debug
 
       score
     end
-    # rubocop:enable Metrics/AbcSize
+
+    # Helper method to normalize dates to YYYY-MM-DD format
+    def normalize_date(date_value)
+      return nil if date_value.nil?
+
+      date_str = date_value.to_s
+
+      # First try to extract YYYY-MM-DD from ISO format
+      date_str = date_str.split("T").first.strip if date_str.include?("T")
+
+      # Handle different date formats
+      begin
+        # Try to parse as Date object if it's not already in YYYY-MM-DD format
+        date_str = Date.parse(date_str).strftime("%Y-%m-%d") unless date_str =~ /^\d{4}-\d{2}-\d{2}$/
+      rescue StandardError => e
+        debug_log "Error normalizing date '#{date_str}': #{e.message}" if @debug
+        # If parsing fails, return the original string
+      end
+
+      date_str
+    end
+
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
     def fetch_assigned_projects
-      @source_projects = @source.projects.all(**@filters.fetch(:source, {}), active: "true")
-      @target_projects = @target.projects.all(**@filters.fetch(:target, {}), active: "true")
-
-      # Ensure we have proper collections
-      @source_projects = if @source_projects.is_a?(MOCO::EntityCollection)
-                           @source_projects
-                         else
-                           MOCO::EntityCollection.new(@source,
-                                                      "projects", "Project").tap do |c|
-                             c.instance_variable_set(:@items, [@source_projects])
-                           end
-                         end
-      @target_projects = if @target_projects.is_a?(MOCO::EntityCollection)
-                           @target_projects
-                         else
-                           MOCO::EntityCollection.new(@target,
-                                                      "projects", "Project").tap do |c|
-                             c.instance_variable_set(:@items, [@target_projects])
-                           end
-                         end
+      # Use .projects.assigned for the source, standard .projects for the target
+      source_filters = @filters.fetch(:source, {}).merge(active: "true")
+      # Get the proxy, then fetch all results into the instance variable
+      @source_projects = @source.projects.assigned.where(source_filters).all
+      debug_log "Found #{@source_projects.size} source projects:"
+      @source_projects.each do |project|
+        debug_log "  Source Project: #{project.id} - #{project.name} (#{project.identifier})"
+        debug_log "    Tasks:"
+        project.tasks.each do |task|
+          debug_log "      Task: #{task.id} - #{task.name}"
+        end
+      end
+
+      target_filters = @filters.fetch(:target, {}).merge(active: "true")
+      # Get the proxy, then fetch all results into the instance variable
+      @target_projects = @target.projects.where(target_filters).all
+      debug_log "Found #{@target_projects.size} target projects:"
+      @target_projects.each do |project|
+        debug_log "  Target Project: #{project.id} - #{project.name} (#{project.identifier})"
+        debug_log "    Tasks:"
+        project.tasks.each do |task|
+          debug_log "      Task: #{task.id} - #{task.name}"
+        end
+      end
+
+      # NOTE: The @source_projects and @target_projects are now Arrays of entities,
+      #       not CollectionProxy or EntityCollection objects.
     end
 
     def build_initial_mappings
@@ -179,11 +395,29 @@ module MOCO
         next unless source_project
 
         @project_mapping[source_project.id] = target_project
+        debug_log "Mapped source project #{source_project.id} (#{source_project.name}) to target project #{target_project.id} (#{target_project.name})"
+
         target_project.tasks.each do |target_task|
           source_task = match_task(target_task, source_project)
-          @task_mapping[source_task.id] = target_task if source_task
+          if source_task
+            @task_mapping[source_task.id] = target_task
+            debug_log "  Mapped source task #{source_task.id} (#{source_task.name}) to target task #{target_task.id} (#{target_task.name})"
+          else
+            debug_log "  No matching source task found for target task #{target_task.id} (#{target_task.name})"
+          end
         end
       end
+
+      # Log the final mappings
+      debug_log "Final project mappings:"
+      @project_mapping.each do |source_id, target_project|
+        debug_log "  Source project #{source_id} -> Target project #{target_project.id} (#{target_project.name})"
+      end
+
+      debug_log "Final task mappings:"
+      @task_mapping.each do |source_id, target_task|
+        debug_log "  Source task #{source_id} -> Target task #{target_task.id} (#{target_task.name})"
+      end
     end
 
     def match_project(target_project)
@@ -192,7 +426,7 @@ module MOCO
 
       # Manually iterate since we can't rely on Enumerable methods
       @source_projects.each do |project|
-        warn project.inspect
+        debug_log "Checking source project: #{project.inspect}" if @debug
         searchable_projects << { original: project, name: project.name }
       end
 

data/lib/moco/version.rb

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

data/lib/moco.rb

@@ -6,6 +6,11 @@ require "active_support/inflector"
 
 require_relative "moco/version"
 
+# Core classes needed by entities
+require_relative "moco/connection"
+require_relative "moco/collection_proxy"
+require_relative "moco/nested_collection_proxy"
+
 # New API (v2)
 require_relative "moco/entities/base_entity"
 require_relative "moco/entities/project"
@@ -22,9 +27,6 @@ require_relative "moco/entities/presence"
 require_relative "moco/entities/holiday"
 require_relative "moco/entities/planning_entry"
 require_relative "moco/client"
-require_relative "moco/connection"
-require_relative "moco/collection_proxy"
-require_relative "moco/nested_collection_proxy"
 require_relative "moco/entity_collection"
 
 require_relative "moco/sync"

data/moco.gemspec

@@ -0,0 +1,36 @@
+# 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

data/sync_activity.rb

@@ -10,7 +10,8 @@ options = {
   to: nil,
   project: nil,
   match_project_threshold: 0.8,
-  match_task_threshold: 0.45
+  match_task_threshold: 0.45,
+  debug: false
 }
 
 OptionParser.new do |opts|
@@ -47,6 +48,10 @@ OptionParser.new do |opts|
   opts.on("--match-task-threshold VALUE", Float, "Task matching threshold (0.0 - 1.0), default 0.45") do |val|
     options[:match_task_threshold] = val
   end
+
+  opts.on("-d", "--debug", "Enable debug output") do
+    options[:debug] = true
+  end
 end.parse!
 
 source_instance = ARGV.shift
@@ -64,8 +69,8 @@ config = YAML.load_file("config.yml")
 source_config = config["instances"].fetch(source_instance, nil)
 target_config = config["instances"].fetch(target_instance, nil)
 
-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"])
+source_client = MOCO::Client.new(subdomain: source_instance, api_key: source_config["api_key"], debug: options[:debug])
+target_client = MOCO::Client.new(subdomain: target_instance, api_key: target_config["api_key"], debug: options[:debug])
 
 syncer = MOCO::Sync.new(
   source_client,
@@ -76,7 +81,8 @@ syncer = MOCO::Sync.new(
     source: options.slice(:from, :to, :project_id, :company_id, :term),
     target: options.slice(:from, :to)
   },
-  dry_run: options[:dry_run]
+  dry_run: options[:dry_run],
+  debug: options[:debug]
 )
 
 syncer.source_projects.each do |project|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moco-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha
+  version: 1.0.0
 platform: ruby
 authors:
 - Teal Bauer
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-10 00:00:00.000000000 Z
+date: 2025-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -94,6 +94,7 @@ 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
@@ -115,9 +116,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.1
 signing_key: