git-fit 0.3.2 → 0.4.6

data/lib/git_fit/import/local_file.rb

@@ -0,0 +1,250 @@
+require "digest"
+require "fileutils"
+require "json"
+require "nokogiri"
+require "tzinfo"
+
+module GitFit
+  module Import
+    class LocalFile < Source::Base
+      IMPORT_DIRS = {
+        "gpx" => "data/import/gpx",
+        "tcx" => "data/import/tcx",
+        "fit" => "data/import/fit"
+      }.freeze
+
+      SUPPORTED_EXTENSIONS = %w[.gpx .tcx .fit].freeze
+
+      NS_TCX = { tcx: "http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2" }.freeze
+
+      def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil, sources: nil, sport_override: nil)
+        super(config:, db:, activity_filter:, privacy:, time_budget:)
+        @sources = sources
+        @sport_override = sport_override
+        @timezone_resolver = GitFit::Timezone::Resolver.new(config)
+      end
+
+      def call
+        return 0 unless authenticate
+
+        total_imported = 0
+        @sources.each do |source|
+          dir = IMPORT_DIRS[source]
+          next unless dir && File.directory?(dir)
+
+          files = Dir.glob(File.join(dir, "*"), File::FNM_CASEFOLD)
+                     .select { |f| SUPPORTED_EXTENSIONS.include?(File.extname(f).downcase) && File.file?(f) }
+
+          total_imported += process_files(files, source)
+        end
+
+        total_imported
+      end
+
+      def authenticate
+        true
+      end
+
+      def pending_ids
+        []
+      end
+
+      def source_label
+        "LocalFile"
+      end
+
+      def raw_dir_for(source)
+        File.join("data", "raw", source)
+      end
+
+      def std_dir_for(source)
+        File.join("data", "std", source)
+      end
+
+      private
+
+      def process_files(files, source)
+        total_activities = 0
+        total = files.size
+
+        files.each_with_index do |file_path, idx|
+          break if time_expired? && total_activities.positive?
+
+          result = process_single_file(file_path, source)
+          if result
+            activity_count = result[:activity_count] || 1
+            total_activities += activity_count
+            report_progress(idx + 1, total, "#{activity_count} act from #{File.basename(file_path)}")
+          end
+        end
+
+        total_activities
+      end
+
+      def process_single_file(file_path, source)
+        content = File.binread(file_path)
+        sha = Digest::SHA256.hexdigest(content)
+        platform_id = "#{source}_#{sha[0, 12]}"
+
+        return nil if existing_run_id?(platform_id)
+
+        ext = File.extname(file_path).downcase
+        raw_source_dir = raw_dir_for(source)
+
+        raw_path = File.join(raw_source_dir, "#{platform_id}#{ext}")
+        FileUtils.mkdir_p(raw_source_dir)
+        tmp = "#{raw_path}.tmp"
+        File.binwrite(tmp, content)
+        File.rename(tmp, raw_path)
+
+        activities = parse_file(ext, content, file_path)
+        return nil if activities.empty?
+
+        l2_points = extract_l2_points(ext, content, file_path)
+
+        imported = 0
+        activities.each do |activity|
+          activity[:source] = source
+          activity[:run_id] = imported.zero? ? platform_id : "#{platform_id}_#{imported}"
+
+          if source == "gpx" && @sport_override
+            activity[:sport_category] = SportMapper.canonicalize(@sport_override)
+          end
+
+          if l2_points&.any?
+            std_source_dir = std_dir_for(source)
+            FileUtils.mkdir_p(std_source_dir)
+            std_data = l2_points.map { |pt|
+              h = { latitude: pt[0], longitude: pt[1] }
+              h[:altitude] = pt[2] if pt[2]
+              h[:timestamp] = pt[3]&.iso8601 if pt[3]
+              h[:heart_rate] = pt[4] if pt[4]
+              h
+            }
+            std_tmp = File.join(std_source_dir, ".#{activity[:run_id]}.json.tmp")
+            std_final = File.join(std_source_dir, "#{activity[:run_id]}.json")
+            File.write(std_tmp, JSON.generate(std_data))
+            File.rename(std_tmp, std_final)
+
+            coords = l2_points.map { |p| [p[0], p[1]] }
+            activity[:summary_polyline] = GitFit::Geo::Polyline.encode(coords)
+
+            first_pt = l2_points.first
+            tz = @timezone_resolver.resolve(first_pt[0], first_pt[1])
+            if tz && activity[:start_date]
+              activity[:start_date_local] = utc_to_local(activity[:start_date], tz)
+            end
+          end
+
+          upsert_activity(activity)
+          imported += 1
+        end
+
+        { activity_count: imported }
+      rescue => e
+        $stderr.puts "LocalFile: error importing #{file_path}: #{e.message}"
+        nil
+      end
+
+      def parse_file(ext, content, file_path)
+        case ext
+        when ".gpx"
+          GitFit::Parser::GPX.new.call(content)
+        when ".tcx"
+          GitFit::Parser::TCX.new.call(content)
+        when ".fit"
+          GitFit::Parser::FIT.new.call(file_path)
+        else
+          []
+        end
+      end
+
+      def extract_l2_points(ext, content, file_path)
+        case ext
+        when ".gpx"
+          extract_gpx_points(content)
+        when ".tcx"
+          extract_tcx_points(content)
+        when ".fit"
+          extract_fit_points(file_path)
+        else
+          nil
+        end
+      end
+
+      def extract_gpx_points(xml)
+        doc = Nokogiri::XML(xml)
+        doc.remove_namespaces!
+        doc.xpath("//trkpt").filter_map do |pt|
+          lat = pt["lat"]&.to_f
+          lon = pt["lon"]&.to_f
+          next unless lat && lon
+          ele = pt.at_xpath("ele")&.text&.to_f
+          time_str = pt.at_xpath("time")&.text
+          time = parse_timestamp(time_str)
+          hr = pt.at_xpath("extensions//hr")&.text&.to_f
+          [lat, lon, ele, time, hr]
+        end
+      rescue => e
+        $stderr.puts "LocalFile: GPX parse error: #{e.message}"
+        nil
+      end
+
+      def extract_tcx_points(xml)
+        doc = Nokogiri::XML(xml)
+        doc.xpath("//tcx:Trackpoint", NS_TCX).filter_map do |tp|
+          pos = tp.at_xpath("tcx:Position", NS_TCX)
+          next unless pos
+          lat = pos.at_xpath("tcx:LatitudeDegrees", NS_TCX)&.text&.to_f
+          lon = pos.at_xpath("tcx:LongitudeDegrees", NS_TCX)&.text&.to_f
+          next unless lat && lon
+          ele = tp.at_xpath("tcx:AltitudeMeters", NS_TCX)&.text&.to_f
+          time_str = tp.at_xpath("tcx:Time", NS_TCX)&.text
+          time = parse_timestamp(time_str)
+          hr = tp.at_xpath("tcx:HeartRateBpm/tcx:Value", NS_TCX)&.text&.to_f
+          [lat, lon, ele, time, hr]
+        end
+      rescue => e
+        $stderr.puts "LocalFile: TCX parse error: #{e.message}"
+        nil
+      end
+
+      def extract_fit_points(file_path)
+        records = GitFit::FIT::Decoder.decode(file_path)
+        records.filter_map do |r|
+          lat = r["positionLat"]
+          lon = r["positionLong"]
+          next unless lat && lon
+          ts = r["timestamp"]
+          time = ts.is_a?(Numeric) ? (Time.utc(1989, 12, 31) + ts) : (Time.parse(ts.to_s) rescue nil)
+          [lat, lon, r["altitude"], time, r["heartRate"]]
+        end
+      rescue => e
+        $stderr.puts "LocalFile: FIT decode error: #{e.message}"
+        nil
+      end
+
+      def parse_timestamp(str)
+        return nil unless str
+        Time.parse(str)
+      rescue ArgumentError
+        nil
+      end
+
+      def existing_run_id?(platform_id)
+        !@db[:activities].where(run_id: platform_id).empty?
+      end
+
+      def utc_to_local(utc_iso8601, tz_name)
+        return utc_iso8601 unless utc_iso8601 && tz_name
+        t = Time.parse(utc_iso8601)
+        return utc_iso8601 unless t.utc?
+        tz = TZInfo::Timezone.get(tz_name)
+        local = tz.utc_to_local(t)
+        local.iso8601
+      rescue TZInfo::InvalidTimezoneIdentifier, ArgumentError
+        utc_iso8601
+      end
+    end
+  end
+end

data/lib/git_fit/import.rb

@@ -0,0 +1,2 @@
+require_relative "import/local_file"
+require_relative "import/apple_health"

data/lib/git_fit/source/base.rb

@@ -0,0 +1,155 @@
+require "date"
+
+module GitFit
+  module Source
+    class Base
+      def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
+        @config = config
+        @db = db
+        @activity_filter = activity_filter
+        @privacy = privacy
+        @time_budget = time_budget
+        @start_time = nil
+        @progress_reported = false
+      end
+
+      attr_reader :progress_reported
+
+      def call
+        return 0 unless before_call
+        return 0 unless respond_to?(:authenticate) ? authenticate : true
+        ids = pending_ids
+        return 0 if ids.nil? || ids.empty?
+        total = ids.size
+        count = 0
+        ids.filter_map do |p|
+          r = process_one(p)
+          count += 1
+          report_progress(count, total, build_progress_info(r)) if r
+          r
+        end.size
+      end
+
+      def before_call
+        @start_time = Time.now
+        true
+      end
+
+      def pending_ids
+        raise NotImplementedError
+      end
+
+      def process_one(pending)
+        raise NotImplementedError
+      end
+
+      def build_progress_info(attrs)
+        parts = []
+        sd = attrs["start_date"] || attrs[:start_date]
+        if sd
+          d = Date.parse(sd.to_s) rescue nil
+          if d
+            date_str = d.year == Date.today.year ? d.strftime("%m-%d") : d.strftime("%Y-%m-%d")
+            parts << date_str
+          end
+        end
+        type = attrs["sport_category"] || attrs[:sport_category]
+        parts << type if type
+        dist = attrs["distance"] || attrs[:distance]
+        if dist && dist.to_f > 0
+          parts << "#{format('%.1f', dist.to_f / 1000)}km"
+        end
+        source = attrs["source"] || attrs[:source] || source_label
+        name = attrs["name"] || attrs[:name]
+        display_name = name.to_s.strip
+        display_name = "#{source} Activity" if display_name.empty?
+        chars = display_name.chars
+        display_name = chars.first(30).join + "…" if chars.size > 30
+        parts << display_name
+        parts.join(" | ") unless parts.empty?
+      end
+
+      protected
+
+      def time_expired?
+        return false unless @time_budget.is_a?(Numeric) && @time_budget > 0 && @start_time
+        (Time.now - @start_time) > @time_budget
+      end
+
+      def raw_dir
+        src = self.class.name.split("::").last.downcase
+        File.join("data", "raw", src)
+      end
+
+      def raw_path(platform_id)
+        raise NotImplementedError
+      end
+
+      def raw_file_exists?(platform_id)
+        File.exist?(raw_path(platform_id))
+      end
+
+      def std_dir
+        src = self.class.name.split("::").last.downcase
+        File.join("data", "std", src)
+      end
+
+      def std_path(platform_id, ext = "json")
+        File.join(std_dir, "#{platform_id}.#{ext}")
+      end
+
+      def report_progress(count, total = nil, info = nil)
+        return unless show_progress?(count, total)
+        @progress_reported = true
+        line = "#{source_label}: #{count}"
+        line += "/#{total}" if total
+        line += " #{info}" if info
+        line += " "
+        print "\r#{line}"
+        $stdout.flush
+      end
+
+      def show_progress?(count, total)
+        return true if count == 1
+        return true if total && (total - count) <= 50
+        step = progress_step(total)
+        step <= 1 || count % step == 0
+      end
+
+      def progress_step(total)
+        return 1 unless total && total > 0
+        [1, (1.5 * (total ** 0.4)).to_i].max
+      end
+
+      def source_label
+        name = self.class.name
+        name ? name.split("::").last : "Source"
+      end
+
+      def upsert_activity(attrs)
+        attrs = attrs.transform_keys(&:to_s)
+        now = Time.now.utc
+
+        if @privacy && !@privacy.before_saving?
+          attrs["summary_polyline"] = @privacy.filter(attrs["summary_polyline"])
+        end
+
+        existing = @db[:activities].where(run_id: attrs["run_id"]).first
+        if existing
+          attrs.delete("created_at")
+          attrs["updated_at"] = now
+          @db[:activities].where(run_id: attrs["run_id"]).update(attrs)
+        else
+          attrs["created_at"] ||= now
+          attrs["updated_at"] ||= now
+          @db[:activities].insert(attrs)
+        end
+      end
+
+      def skip_type?(sport_type)
+        return false unless @activity_filter
+        !@activity_filter.include?(sport_type.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/git_fit/source/tally.rb

@@ -0,0 +1,55 @@
+module GitFit
+  module Source
+    class Tally
+      DIGITS = %w[零 一 二 三 四 五 六 七 八 九 十]
+
+      def initialize(count = 0)
+        @count = count
+      end
+
+      def add(n = 1)
+        @count += n
+      end
+
+      def to_s
+        return @count.to_s if @count > 9999
+        chinese_numeral
+      rescue StandardError
+        @count.to_s
+      end
+
+      private
+
+      def chinese_numeral
+        n = @count
+        return DIGITS[0] if n == 0
+        return DIGITS[n] if n <= 10
+
+        result = ""
+        thousands = n / 1000
+        n %= 1000
+        result += DIGITS[thousands] + "千" if thousands > 0
+
+        hundreds = n / 100
+        n %= 100
+        if hundreds > 0
+          result += DIGITS[hundreds] + "百"
+        elsif thousands > 0 && n > 0
+          result += "零"
+        end
+
+        tens = n / 10
+        ones = n % 10
+        if tens > 0
+          join_ten = tens > 1 || !result.empty?
+          result += (join_ten ? DIGITS[tens] : "") + "十"
+        elsif !result.empty? && tens == 0 && ones > 0 && !result.end_with?("零")
+          result += "零"
+        end
+
+        result += DIGITS[ones] if ones > 0
+        result
+      end
+    end
+  end
+end

data/lib/git_fit/source.rb

@@ -0,0 +1,7 @@
+module GitFit
+  module Source
+  end
+end
+
+require_relative "source/tally"
+require_relative "source/base"

data/lib/git_fit/version.rb

@@ -1,3 +1,3 @@
 module GitFit
-  VERSION = "0.3.2"
+  VERSION = "0.4.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.6
 platform: ruby
 authors:
 - Lax
@@ -93,6 +93,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: A git extension CLI for aggregating, managing, and exporting fitness
   activity data from multiple sources (Garmin, Strava, Keep, etc.)
 email:
@@ -105,22 +133,33 @@ files:
 - exe/git-fit
 - lib/git-fit.rb
 - lib/git_fit/cli.rb
+- lib/git_fit/cli/export.rb
+- lib/git_fit/cli/import_cli.rb
 - lib/git_fit/config.rb
 - lib/git_fit/config_template.rb
 - lib/git_fit/db/activity.rb
 - lib/git_fit/db/cli.rb
 - lib/git_fit/db/connection.rb
+- lib/git_fit/export.rb
+- lib/git_fit/export/defaults.rb
+- lib/git_fit/export/json.rb
 - lib/git_fit/fit.rb
 - lib/git_fit/fit/decoder.rb
 - lib/git_fit/geo.rb
 - lib/git_fit/geo/coord_transform.rb
 - lib/git_fit/geo/polyline.rb
+- lib/git_fit/import.rb
+- lib/git_fit/import/apple_health.rb
+- lib/git_fit/import/local_file.rb
 - lib/git_fit/parser.rb
 - lib/git_fit/parser/base.rb
 - lib/git_fit/parser/fit.rb
 - lib/git_fit/parser/gpx.rb
 - lib/git_fit/parser/tcx.rb
 - lib/git_fit/privacy/polyline_filter.rb
+- lib/git_fit/source.rb
+- lib/git_fit/source/base.rb
+- lib/git_fit/source/tally.rb
 - lib/git_fit/sport_mapper.rb
 - lib/git_fit/sync/base.rb
 - lib/git_fit/sync/strava.rb