moco-ruby 0.1.1 → 1.0.0.alpha

data/lib/moco/sync.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "fuzzy_match"
-require_relative "api"
+require_relative "client"
 
 module MOCO
   # Match and map projects and tasks between MOCO instances and sync activities
@@ -9,9 +9,9 @@ module MOCO
     attr_reader :project_mapping, :task_mapping, :source_projects, :target_projects
     attr_accessor :project_match_threshold, :task_match_threshold, :dry_run
 
-    def initialize(source_instance_api, target_instance_api, **args)
-      @source_api = source_instance_api
-      @target_api = target_instance_api
+    def initialize(source_client, target_client, **args)
+      @source = source_client
+      @target = target_client
       @project_match_threshold = args.fetch(:project_match_threshold, 0.8)
       @task_match_threshold = args.fetch(:task_match_threshold, 0.45)
       @filters = args.fetch(:filters, {})
@@ -24,12 +24,12 @@ module MOCO
       build_initial_mappings
     end
 
-    # rubocop:todo Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def sync(&callbacks)
       results = []
 
-      source_activities_r = @source_api.get_activities(@filters.fetch(:source, {}))
-      target_activities_r = @target_api.get_activities(@filters.fetch(:target, {}))
+      source_activities_r = @source.activities.all(@filters.fetch(:source, {}))
+      target_activities_r = @target.activities.all(@filters.fetch(:target, {}))
 
       source_activities_grouped = source_activities_r.group_by(&:date).transform_values do |activities|
         activities.group_by(&:project)
@@ -38,6 +38,9 @@ module MOCO
         activities.group_by(&:project)
       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], [])
@@ -46,9 +49,6 @@ module MOCO
           matches = calculate_matches(source_activities, target_activities)
           matches.sort_by! { |match| -match[:score] }
 
-          used_source_activities = []
-          used_target_activities = []
-
           matches.each do |match|
             source_activity, target_activity = match[:activity]
             score = match[:score]
@@ -70,14 +70,14 @@ module MOCO
               end
               callbacks&.call(:update, source_activity, best_match)
               unless @dry_run
-                results << @target_api.update_activity(best_match)
+                results << @target.activities.update(best_match)
                 callbacks&.call(:updated, source_activity, best_match, results.last)
               end
             when 0...60
               # <60 - no good match found, create new entry
               callbacks&.call(:create, source_activity, expected_target_activity)
               unless @dry_run
-                results << @target_api.create_activity(expected_target_activity)
+                results << @target.activities.create(expected_target_activity)
                 callbacks&.call(:created, source_activity, best_match, results.last)
               end
             end
@@ -87,6 +87,19 @@ module MOCO
           end
         end
       end
+
+      source_activities_r.each do |source_activity|
+        next if used_source_activities.include?(source_activity)
+        next unless @project_mapping[source_activity.project.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
+      end
+
       results
     end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -105,7 +118,7 @@ module MOCO
       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: score }
+          matches << { activity: [source_activity, target_activity], score: }
         end
       end
       matches
@@ -138,8 +151,26 @@ module MOCO
     # rubocop:enable Metrics/AbcSize
 
     def fetch_assigned_projects
-      @source_projects = @source_api.get_assigned_projects(**@filters.fetch(:source, {}).merge(active: "true"))
-      @target_projects = @target_api.get_assigned_projects(**@filters.fetch(:target, {}).merge(active: "true"))
+      @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
     end
 
     def build_initial_mappings
@@ -156,13 +187,37 @@ module MOCO
     end
 
     def match_project(target_project)
-      matcher = FuzzyMatch.new(@source_projects, read: :name)
-      matcher.find(target_project.name, threshold: @project_match_threshold)
+      # Create array of search objects manually since we can't call map on EntityCollection
+      searchable_projects = []
+
+      # Manually iterate since we can't rely on Enumerable methods
+      @source_projects.each do |project|
+        warn project.inspect
+        searchable_projects << { original: project, name: project.name }
+      end
+
+      matcher = FuzzyMatch.new(searchable_projects, read: :name)
+      match = matcher.find(target_project.name, threshold: @project_match_threshold)
+      match[:original] if match
     end
 
     def match_task(target_task, source_project)
-      matcher = FuzzyMatch.new(source_project.tasks, read: :name)
-      matcher.find(target_task.name, threshold: @task_match_threshold)
+      # Get tasks from the source project
+      tasks = source_project.tasks
+
+      # Create array of search objects manually since we can't rely on Enumerable methods
+
+      # Manually iterate through tasks
+      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
     end
   end
 end

data/lib/moco/version.rb

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

data/lib/moco.rb

@@ -1,8 +1,32 @@
 # frozen_string_literal: true
 
+require "active_support"
+require "active_support/core_ext"
+require "active_support/inflector"
+
 require_relative "moco/version"
-require_relative "moco/entities"
-require_relative "moco/api"
+
+# New API (v2)
+require_relative "moco/entities/base_entity"
+require_relative "moco/entities/project"
+require_relative "moco/entities/activity"
+require_relative "moco/entities/user"
+require_relative "moco/entities/company"
+require_relative "moco/entities/task"
+require_relative "moco/entities/invoice"
+require_relative "moco/entities/deal"
+require_relative "moco/entities/expense"
+require_relative "moco/entities/web_hook"
+require_relative "moco/entities/schedule"
+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"
 
 module MOCO

data/mocurl.rb

@@ -58,42 +58,59 @@ end
 
 # Load default API key from config
 config = YAML.load_file("config.yml")
-options[:api_key] ||= config["instances"].fetch(subdomain, nil)&.fetch("api_key", nil)
+options[:api_key] ||= config["instances"].dig(subdomain, "api_key")
 
 warn "Error: No API key found for `#{subdomain}' and none given, continuing without" if options[:api_key].nil?
 
-api = MOCO::API.new(subdomain, options[:api_key])
-
-case options[:method]
-when "GET"
-  result = api.get(url)
-when "DELETE"
-  result = api.delete(url)
-when "POST"
-  result = api.post(url, options[:data])
-when "PUT"
-  result = api.put(url, options[:data])
-when "PATCH"
-  result = api.patch(url, options[:data])
-else
-  puts "Error: Invalid HTTP Method: #{options[:method]}"
-  exit 1
-end
+client = MOCO::Client.new(subdomain: subdomain, api_key: options[:api_key])
+
+# Extract path from URL
+path = url.gsub(%r{https?://#{subdomain}\.mocoapp\.com/api/v1/}, "")
+
+begin
+  # Make request using the client's connection directly
+  result = case options[:method]
+           when "GET"
+             client.connection.get(path)
+           when "DELETE"
+             client.connection.delete(path)
+           when "POST"
+             client.connection.post(path, options[:data])
+           when "PUT"
+             client.connection.put(path, options[:data])
+           when "PATCH"
+             client.connection.patch(path, options[:data])
+           else
+             puts "Error: Invalid HTTP Method: #{options[:method]}"
+             exit 1
+           end
+
+  if options[:verbose]
+    puts "> #{options[:method]} #{url}"
+    # Print request details if available
+    if result.env&.request_headers
+      puts(result.env.request_headers.map do |k, v|
+        "> #{k}: #{k == "Authorization" ? "#{v[0...16]}<REDACTED>#{v[-4..]}" : v}"
+      end)
+      puts ">"
+      puts result.env.request_body.split.map { |l| "> #{l}" }.join if result.env.request_body
+      puts "---"
+      puts "< #{result.status} #{result.reason_phrase}"
+      puts(result.headers.map { |k, v| "< #{k}: #{v}" })
+    else
+      puts "> Request details not available in this response format"
+    end
+    puts ""
+  end
 
-if options[:verbose]
-  puts "> #{options[:method]} #{result.env.url}"
-  puts(result.env.request_headers.map do |k, v|
-         "> #{k}: #{k == "Authorization" ? "#{v[0...16]}<REDACTED>#{v[-4..]}" : v}"
-       end)
-  puts ">"
-  puts result.env.request_body.split.map { |l| "> #{l}" }.join if result.env.request_body
-  puts "---"
-  puts "< #{result.status} #{result.reason_phrase}"
-  puts(result.headers.map { |k, v| "< #{k}: #{v}" })
-  puts ""
-end
-if options[:no_format]
-  puts result.body.to_json
-else
-  puts JSON.pretty_generate(result.body)
+  # Format the response
+  response_data = result.body
+  if options[:no_format]
+    puts response_data.to_json
+  else
+    puts JSON.pretty_generate(response_data)
+  end
+rescue StandardError => e
+  puts "Error: #{e.message}"
+  exit 1
 end

data/sync_activity.rb

@@ -64,12 +64,12 @@ config = YAML.load_file("config.yml")
 source_config = config["instances"].fetch(source_instance, nil)
 target_config = config["instances"].fetch(target_instance, nil)
 
-source_api = MOCO::API.new(source_instance, source_config["api_key"])
-target_api = MOCO::API.new(target_instance, target_config["api_key"])
+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"])
 
 syncer = MOCO::Sync.new(
-  source_api,
-  target_api,
+  source_client,
+  target_client,
   project_match_threshold: options[:match_project_threshold],
   task_match_threshold: options[:match_task_threshold],
   filters: {

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: moco-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0.alpha
 platform: ruby
 authors:
 - Teal Bauer
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-27 00:00:00.000000000 Z
+date: 2025-04-10 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
@@ -55,20 +69,40 @@ files:
 - README.md
 - Rakefile
 - config.yml.sample
+- examples/v2_api_example.rb
 - lib/moco.rb
-- lib/moco/api.rb
+- lib/moco/client.rb
+- lib/moco/collection_proxy.rb
+- lib/moco/connection.rb
 - lib/moco/entities.rb
+- lib/moco/entities/activity.rb
+- lib/moco/entities/base_entity.rb
+- lib/moco/entities/company.rb
+- lib/moco/entities/deal.rb
+- lib/moco/entities/expense.rb
+- lib/moco/entities/holiday.rb
+- lib/moco/entities/invoice.rb
+- lib/moco/entities/planning_entry.rb
+- lib/moco/entities/presence.rb
+- lib/moco/entities/project.rb
+- lib/moco/entities/schedule.rb
+- lib/moco/entities/task.rb
+- lib/moco/entities/user.rb
+- lib/moco/entities/web_hook.rb
+- lib/moco/entity_collection.rb
+- lib/moco/helpers.rb
+- lib/moco/nested_collection_proxy.rb
 - lib/moco/sync.rb
 - lib/moco/version.rb
 - mocurl.rb
 - sync_activity.rb
-homepage: https://github.com/moeffju/moco-ruby
+homepage: https://github.com/starsong-consulting/moco-ruby
 licenses:
 - Apache-2.0
 metadata:
-  homepage_uri: https://github.com/moeffju/moco-ruby
-  source_code_uri: https://github.com/moeffju/moco-ruby
-  changelog_uri: https://github.com/moeffju/moco-ruby/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/starsong-consulting/moco-ruby
+  source_code_uri: https://github.com/starsong-consulting/moco-ruby
+  changelog_uri: https://github.com/starsong-consulting/moco-ruby/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -78,12 +112,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.4.1
 signing_key:

data/lib/moco/api.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require_relative "entities"
-
-module MOCO
-  # MOCO::API abstracts access to the MOCO API and its entities
-  class API
-    def initialize(subdomain, api_key)
-      @subdomain = subdomain
-      @api_key = api_key
-      @conn = Faraday.new do |f|
-        f.request :json
-        f.response :json
-        f.request :authorization, "Token", "token=#{@api_key}" if @api_key
-        f.url_prefix = "https://#{@subdomain}.mocoapp.com/api/v1"
-      end
-    end
-
-    %w[get post put patch delete].each do |method|
-      define_method(method) do |path, *args|
-        @conn.send(method, path, *args)
-      end
-    end
-
-    def get_projects(**args)
-      response = @conn.get("projects?#{Faraday::Utils.build_query(args)}")
-      parse_projects_response(response.body)
-    end
-
-    def get_assigned_projects(**args)
-      response = @conn.get("projects/assigned?#{Faraday::Utils.build_query(args)}")
-      parse_projects_response(response.body)
-    end
-
-    def get_activities(filters = {})
-      response = @conn.get("activities?#{Faraday::Utils.build_query(filters)}")
-      parse_activities_response(response.body)
-    end
-
-    def create_activity(activity)
-      api_entity = activity.to_h.except(:id, :project, :user, :customer).tap do |h|
-        h[:project_id] = activity.project.id
-        h[:task_id] = activity.task.id
-      end
-      @conn.post("activities", api_entity)
-    end
-
-    def update_activity(activity)
-      api_entity = activity.to_h.except(:project, :user, :customer).tap do |h|
-        h[:project_id] = activity.project.id
-        h[:task_id] = activity.task.id
-      end
-      @conn.put("activities/#{activity.id}", api_entity)
-    end
-
-    private
-
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def parse_projects_response(data)
-      data.map do |project_data|
-        Project.new.tap do |project|
-          project.id = project_data["id"]
-          project.name = project_data["name"]
-          project.customer = parse_customer_reference(project_data["customer"])
-          project.tasks = project_data["tasks"].map do |task_data|
-            Task.new.tap do |task|
-              task.id = task_data["id"]
-              task.name = task_data["name"]
-              task.project_id = task_data["project_id"]
-              task.billable = task_data["billable"]
-            end
-          end
-        end
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def parse_activities_response(data)
-      data.map do |activity_data|
-        Activity.new.tap do |activity|
-          activity.id = activity_data["id"]
-          activity.date = activity_data["date"]
-          activity.description = activity_data["description"]
-          activity.user = parse_user_reference(activity_data["user"])
-          activity.customer = parse_customer_reference(activity_data["customer"])
-          activity.project = parse_project_reference(activity_data["project"])
-          activity.task = parse_task_reference(activity_data["task"])
-          activity.hours = activity_data["hours"]
-          activity.seconds = activity_data["seconds"]
-          activity.billable = activity_data["billable"]
-          activity.billed = activity_data["billed"]
-          activity.tag = activity_data["tag"]
-        end
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
-    def parse_project_reference(project_data)
-      Project.new.tap do |project|
-        project.id = project_data["id"]
-        project.name = project_data["name"]
-      end
-    end
-
-    def parse_task_reference(task_data)
-      Task.new.tap do |task|
-        task.id = task_data["id"]
-        task.name = task_data["name"]
-      end
-    end
-
-    def parse_user_reference(user_data)
-      User.new.tap do |user|
-        user.id = user_data["id"]
-        user.firstname = user_data["firstname"]
-        user.lastname = user_data["lastname"]
-      end
-    end
-
-    def parse_customer_reference(customer_data)
-      Customer.new.tap do |customer|
-        customer.id = customer_data["id"]
-        customer.name = customer_data["name"]
-      end
-    end
-  end
-end