geminize 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 276d207ee68fba0c8b4ea894c819254d660cd1c8b520df5d21a6de89d2cf0b25
-  data.tar.gz: b9447a5ce82b5f10bfda7c09cdd2a658a5d540f1482a741f8ae7651826cce8bd
+  metadata.gz: c08ca1105b496592ec06cd7b7aab2b1b9a1dde2cb0f1c31be6feda85281683a2
+  data.tar.gz: ae7352a06b607dbd1e98cf30cd069551765156d088513a4cf780f94033d8ab89
 SHA512:
-  metadata.gz: 8f0f49ad1678d7edd5e39329ae5dd11749094bdbc4c5fa11676af9c5962a316baf9b96f78967cc159e1de9839ee21bc3693b8e9c5d130eae4bba70fe81e5dcc5
-  data.tar.gz: bb0b7e7437cbbfeda3b522ab737c9521f78fe2252a6cb8b885bbb34b33bc402230dbb24bc9c761857c005c1d595a7c7aa85fe214a338f53a8a1bc4d6fee4305f
+  metadata.gz: 9041ba768b03996f4b2a6fdd9d45dd9a1430298d6d555e54951a9736e24ac713397b1010ffb640bd3a3bcb5b647eb37d15193852e0df31cdfb9bafe6da6a6779
+  data.tar.gz: 3a99e5d5a7e2a7b1d3b8ac7d6ca3450a8a54dd4636b614fa53b4e6175e0ead68981ecb7390b00f9d6c7f5f4fd3bcb9bb44e46b84d9e97702cdca7803227fc022

data/CHANGELOG.md

@@ -1,4 +1,10 @@
-## [Unreleased]
+## [1.0.0] - 2025-05-02
+
+### Removed
+
+- Removed Rails-related integration from the gem, simplifying usage.
+
+## [0.1.1] - 2025-05-01
 
 ### Added
 

data/README.md

@@ -11,7 +11,6 @@ A convenient and robust Ruby interface for the Google Gemini API, enabling easy
 - Embeddings generation
 - Support for streaming responses
 - Comprehensive error handling
-- Rails integration with controller concerns and view helpers
 
 ## Installation
 
@@ -311,120 +310,20 @@ end
 puts "\n" # Add a newline after streaming
 ```
 
-## Rails Integration
-
-Geminize provides seamless integration with Rails applications.
-
-### Setup
-
-1. Add Geminize to your Gemfile:
-
-```ruby
-gem 'geminize'
-```
-
-2. Run the installer generator:
-
-```bash
-rails generate geminize:install
-```
-
-This creates a configuration initializer at `config/initializers/geminize.rb`
-
-3. Add your API key to the initializer or via environment variables.
-
-### Controller Integration
-
-In your controllers, include the Geminize controller concern:
-
-```ruby
-class ChatController < ApplicationController
-  # Add Geminize functionality to this controller
-  geminize_controller
-
-  def index
-    # Optionally reset the conversation
-    # reset_gemini_conversation("New chat session") if params[:reset]
-  end
-
-  def create
-    # Send a message to Gemini and get the response
-    @response = send_gemini_message(params[:message])
-
-    respond_to do |format|
-      format.html { redirect_to chat_path }
-      format.turbo_stream
-      format.json { render json: { message: @response.text } }
-    end
-  end
-end
-```
-
-The concern provides the following methods:
-
-- `current_gemini_conversation` - Access the current conversation (stored in session)
-- `send_gemini_message(message, model_name=nil, params={})` - Send a message in the current conversation
-- `generate_gemini_text(prompt, model_name=nil, params={})` - Generate text with Gemini
-- `generate_gemini_multimodal(prompt, images, model_name=nil, params={})` - Generate text with images
-- `generate_gemini_embedding(text, model_name=nil, params={})` - Generate embeddings
-- `reset_gemini_conversation(title=nil)` - Start a new conversation
-
-### View Integration
-
-Include the Geminize view helpers in your application:
-
-```ruby
-# In app/helpers/application_helper.rb
-module ApplicationHelper
-  # Include Geminize view helpers
-  geminize_helper
-end
-```
-
-This provides the following helper methods:
-
-- `render_gemini_conversation(conversation=nil, options={})` - Render the conversation as HTML
-- `render_gemini_message(message, options={})` - Render a single message
-- `gemini_chat_form(options={})` - Create a chat form
-- `markdown_to_html(text, options={})` - Render Markdown as HTML (requires redcarpet gem)
-- `highlight_code(html)` - Add syntax highlighting to code blocks (requires rouge gem)
-
-Example view:
-
-```erb
-<%# app/views/chat/index.html.erb %>
-<div class="chat-container">
-  <h1>Chat with Gemini</h1>
-
-  <div class="conversation">
-    <%= render_gemini_conversation %>
-  </div>
-
-  <div class="chat-form">
-    <%= gemini_chat_form(placeholder: "Ask me anything...", submit_text: "Send") %>
-  </div>
-</div>
-```
-
-## Example Applications
-
 Check out these example applications to see Geminize in action:
 
 - [Configuration Example](examples/configuration.rb)
 - [Embeddings Example](examples/embeddings.rb)
 - [Multimodal Example](examples/multimodal.rb)
-- [Rails Initializer Example](examples/rails_initializer.rb)
 - [System Instructions Example](examples/system_instructions.rb)
-- [Rails Chat Application](examples/rails_chat)
 
 ## Compatibility
 
 Ruby version: 3.1.0 or later
-Rails version: 6.0 or later (for Rails integration)
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`.
 

data/examples/README.md

@@ -11,10 +11,9 @@ Before running these examples, ensure you have:
 3.  **Project dependencies installed**: Run `bundle install` from the project root directory (`../`).
 4.  **Google Gemini API Key configured**: Create a `.env` file in the project root (`../`) by copying `.env.example` and adding your API key:
     ```bash
-    # In ../.env
-    GOOGLE_AI_API_KEY=your_api_key_here
+    # In .env
+    GEMINI_API_KEY=your_api_key_here
     ```
-    Alternatively, ensure the `GEMINI_API_KEY` environment variable is set.
 
 ## Running Examples
 
@@ -25,7 +24,7 @@ All examples should be run from the **project root directory** (the directory co
 Demonstrates different ways to configure the Geminize client.
 
 ```bash
-ruby examples/configuration.rb
+bundle exec ruby examples/configuration.rb
 ```
 
 ### 2. Embeddings (`embeddings.rb`)
@@ -33,7 +32,7 @@ ruby examples/configuration.rb
 Shows how to generate text embeddings and calculate cosine similarity.
 
 ```bash
-ruby examples/embeddings.rb
+bundle exec ruby examples/embeddings.rb
 ```
 
 ### 3. Multimodal (`multimodal.rb`)
@@ -43,33 +42,13 @@ Illustrates sending text and image inputs to the Gemini API.
 _Note: You may need to update the image file paths within the script (`path/to/image.jpg`) to point to actual image files on your system._
 
 ```bash
-ruby examples/multimodal.rb
+bundle exec ruby examples/multimodal.rb
 ```
 
-### 4. Rails Initializer (`rails_initializer.rb`)
-
-Shows the configuration structure typically used in a Rails initializer (this script is meant for illustration and doesn't require a Rails app to run).
-
-```bash
-ruby examples/rails_initializer.rb
-```
-
-### 5. System Instructions (`system_instructions.rb`)
+### 4. System Instructions (`system_instructions.rb`)
 
 Demonstrates using system instructions to guide the model's behavior and personality.
 
 ```bash
-ruby examples/system_instructions.rb
+bundle exec ruby examples/system_instructions.rb
 ```
-
-### 6. Rails Chat Application (`rails_chat/`)
-
-This directory contains a sample Rails application demonstrating Geminize integration. It requires a separate setup:
-
-1.  Navigate into the directory: `cd examples/rails_chat`
-2.  Install dependencies: `bundle install`
-3.  Run database migrations (if applicable): `rails db:migrate`
-4.  Start the Rails server: `rails server`
-5.  Open your web browser to `http://localhost:3000`
-
-Refer to the README within the `rails_chat/` directory (if available) for more specific instructions.

data/examples/embeddings.rb

@@ -55,7 +55,6 @@ begin
 
   puts "\nGenerated #{embeddings.size} embeddings."
   puts "Total tokens (approximated by summing individual calls): #{total_tokens}"
-
 rescue => e
   puts "Error: #{e.message}"
 end
@@ -85,25 +84,24 @@ end
 puts "\n============================================================"
 puts "Example 4: Batch processing for large arrays (COMMENTED OUT)"
 puts "============================================================"
-=begin # Commenting out Example 4 due to potential model/API limitations with batching
-begin
-  # Create a larger array of texts
-  many_texts = Array.new(120) { |i| "This is sample text number #{i}" }
-
-  # Generate embeddings with automatic batch processing
-  response = Geminize.generate_embedding(
-    many_texts,
-    nil, # Use default model
-    batch_size: 40 # Process in batches of 40 texts each
-  )
-
-  puts "Generated embeddings for #{response.batch_size} texts"
-  puts "First text embedding dimensions: #{response.embedding_size}"
-  puts "Total tokens processed: #{response.total_tokens}"
-rescue => e
-  puts "Error: #{e.message}"
-end
-=end
+# # Commenting out Example 4 due to potential model/API limitations with batching
+# begin
+#   # Create a larger array of texts
+#   many_texts = Array.new(120) { |i| "This is sample text number #{i}" }
+#
+#   # Generate embeddings with automatic batch processing
+#   response = Geminize.generate_embedding(
+#     many_texts,
+#     nil, # Use default model
+#     batch_size: 40 # Process in batches of 40 texts each
+#   )
+#
+#   puts "Generated embeddings for #{response.batch_size} texts"
+#   puts "First text embedding dimensions: #{response.embedding_size}"
+#   puts "Total tokens processed: #{response.total_tokens}"
+# rescue => e
+#   puts "Error: #{e.message}"
+# end
 puts "# Example 4 skipped due to potential issues with batch embedding support."
 
 puts "\n============================================================"

data/examples/multimodal.rb

@@ -20,7 +20,7 @@ begin
   # Generate content with an image from a file
   response = Geminize.generate_text_multimodal(
     "Describe this image in detail:",
-    [{source_type: "file", data: "./examples/ruby.png"}] # Updated path
+    [{source_type: "file", data: File.join(File.dirname(__FILE__), "ruby.png")}] # Use relative path from script
   )
 
   puts "Response:"
@@ -28,7 +28,7 @@ begin
   puts "\nFinish reason: #{response.finish_reason}"
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure the path './examples/ruby.png' is correct relative to the project root."
+  puts "Make sure the path './ruby.png' is correct relative to the project root."
 end
 
 puts "\n============================================================"
@@ -60,8 +60,8 @@ begin
   response = Geminize.generate_text_multimodal(
     "Compare these two images and describe the differences (they might be the same):",
     [
-      {source_type: "file", data: "./examples/ruby.png"}, # Updated path
-      {source_type: "file", data: "./examples/ruby.png"}  # Updated path
+      {source_type: "file", data: File.join(File.dirname(__FILE__), "ruby.png")}, # Use relative path from script
+      {source_type: "file", data: File.join(File.dirname(__FILE__), "ruby.png")}  # Use relative path from script
     ],
     "gemini-1.5-pro-latest", # Explicitly specify model
     max_tokens: 500
@@ -71,7 +71,7 @@ begin
   puts response.text
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure the path './examples/ruby.png' is correct."
+  puts "Make sure the path './ruby.png' is correct."
 end
 
 puts "\n============================================================"
@@ -80,7 +80,7 @@ puts "============================================================"
 
 begin
   # Read image directly into bytes
-  image_bytes = File.binread("./examples/ruby.png") # Updated path
+  image_bytes = File.binread(File.join(File.dirname(__FILE__), "ruby.png")) # Use relative path from script
 
   # Generate content with raw image bytes
   response = Geminize.generate_text_multimodal(
@@ -92,7 +92,7 @@ begin
   puts response.text
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure the path './examples/ruby.png' is correct."
+  puts "Make sure the path './ruby.png' is correct."
 end
 
 puts "\n============================================================"
@@ -112,7 +112,7 @@ begin
   )
 
   # Add multiple images using different methods
-  request.add_image_from_file("./examples/ruby.png") # Updated path
+  request.add_image_from_file(File.join(File.dirname(__FILE__), "ruby.png")) # Use relative path from script
   request.add_image_from_url("https://miro.medium.com/v2/resize:fit:720/format:webp/1*zkA1cWgJDlMUxI5TRcIHdQ.jpeg") # Updated URL
 
   # Generate the response
@@ -122,7 +122,7 @@ begin
   puts response.text
 
   # Check if usage data is available before accessing it
-  if response.usage && response.usage.total_tokens
+  if response.usage&.total_tokens
     puts "\nUsed #{response.usage.total_tokens} tokens total"
   else
     puts "\nUsage data not available in the response."

data/lib/geminize/models/content_request.rb

@@ -214,7 +214,7 @@ module Geminize
         # Map content_parts to the structure the API expects
         api_parts = @content_parts.map do |part|
           if part[:type] == "text"
-            { text: part[:text] }
+            {text: part[:text]}
           elsif part[:type] == "image"
             {
               inlineData: {

data/lib/geminize/version.rb

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

data/lib/geminize.rb

@@ -37,9 +37,6 @@ require_relative "geminize/conversation_repository"
 require_relative "geminize/conversation_service"
 require_relative "geminize/model_info"
 
-# Conditionally load Rails integration if Rails is defined
-require_relative "geminize/rails" if defined?(::Rails)
-
 # Main module for the Geminize gem
 module Geminize
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geminize
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Nhat Long Nguyen
@@ -123,8 +123,7 @@ dependencies:
         version: '2.8'
 description: A convenient and robust Ruby interface for the Google Gemini API, enabling
   easy integration of powerful generative AI models into your applications. Includes
-  support for text generation, chat conversations, embeddings, multimodal content,
-  and Rails integration.
+  support for text generation, chat conversations, embeddings, multimodal content.
 email:
 - nhatlongnguyen1992@gmail.com
 executables: []
@@ -144,14 +143,8 @@ files:
 - examples/configuration.rb
 - examples/embeddings.rb
 - examples/multimodal.rb
-- examples/rails_chat/README.md
-- examples/rails_chat/app/controllers/chat_controller.rb
-- examples/rails_chat/app/views/chat/index.html.erb
-- examples/rails_chat/config/routes.rb
-- examples/rails_initializer.rb
 - examples/ruby.png
 - examples/system_instructions.rb
-- geminize-0.1.0.gem
 - lib/geminize.rb
 - lib/geminize/chat.rb
 - lib/geminize/client.rb
@@ -176,21 +169,11 @@ files:
 - lib/geminize/models/model.rb
 - lib/geminize/models/model_list.rb
 - lib/geminize/models/stream_response.rb
-- lib/geminize/rails.rb
-- lib/geminize/rails/app/controllers/concerns/geminize/controller.rb
-- lib/geminize/rails/app/helpers/geminize_helper.rb
-- lib/geminize/rails/controller_additions.rb
-- lib/geminize/rails/engine.rb
-- lib/geminize/rails/helper_additions.rb
-- lib/geminize/railtie.rb
 - lib/geminize/request_builder.rb
 - lib/geminize/text_generation.rb
 - lib/geminize/validators.rb
 - lib/geminize/vector_utils.rb
 - lib/geminize/version.rb
-- lib/generators/geminize/install_generator.rb
-- lib/generators/geminize/templates/README
-- lib/generators/geminize/templates/initializer.rb
 - sig/geminize.rbs
 homepage: https://github.com/nhlongnguyen/geminize
 licenses:

data/examples/rails_chat/README.md

@@ -1,69 +0,0 @@
-# Rails Chat Example
-
-This is a basic example of how to implement a chat application with the Geminize gem in a Rails application.
-
-## Features
-
-- Chat interface with Google's Gemini AI
-- Conversation memory between requests using Rails session
-- Support for Turbo and JSON responses
-- Reset conversation functionality
-
-## Implementation
-
-This example demonstrates:
-
-1. How to include Geminize controller concerns
-2. How to use Geminize view helpers
-3. How to maintain conversation state in a Rails application
-
-## File Structure
-
-- `app/controllers/chat_controller.rb` - Controller with Geminize integration
-- `app/views/chat/index.html.erb` - Chat interface view
-- `config/routes.rb` - Routes configuration
-
-## Setup in Your Application
-
-1. Add Geminize to your Gemfile:
-
-```ruby
-gem 'geminize'
-```
-
-2. Run the installer:
-
-```bash
-rails generate geminize:install
-```
-
-3. Configure your API key in `config/initializers/geminize.rb`
-
-4. Include the Geminize helpers in your `ApplicationHelper`
-
-```ruby
-module ApplicationHelper
-  geminize_helper
-end
-```
-
-5. Create your controller with Geminize support
-
-```ruby
-class YourChatController < ApplicationController
-  geminize_controller
-
-  # ... your controller actions
-end
-```
-
-6. Use the helper methods in your views
-
-```erb
-<%= render_gemini_conversation %>
-<%= gemini_chat_form %>
-```
-
-## Styling
-
-This example includes basic CSS to style the chat interface. Feel free to customize it to match your application's design.

data/examples/rails_chat/app/controllers/chat_controller.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-class ChatController < ApplicationController
-  # Include Geminize controller functionality
-  geminize_controller
-
-  def index
-    # Reset conversation if requested
-    reset_gemini_conversation("Chat with Gemini") if params[:reset]
-  end
-
-  def create
-    @response = send_gemini_message(params[:message])
-
-    respond_to do |format|
-      format.html { redirect_to chat_path }
-      format.turbo_stream
-      format.json { render json: {message: @response.text} }
-    end
-  end
-
-  def reset
-    reset_gemini_conversation("New Chat Session")
-    redirect_to chat_path, notice: "Started a new conversation"
-  end
-end

data/examples/rails_chat/app/views/chat/index.html.erb

@@ -1,112 +0,0 @@
-<%# Chat index view %>
-<div class="chat-container">
-  <div class="chat-header">
-    <h1>Chat with Gemini</h1>
-    <%= link_to "Start New Chat", reset_chat_path, class: "new-chat-button", data: { turbo_method: :post } %>
-  </div>
-
-  <div class="conversation-container">
-    <div class="conversation">
-      <%= render_gemini_conversation(nil, include_timestamps: true) %>
-    </div>
-  </div>
-
-  <div class="chat-form-container">
-    <%= gemini_chat_form(
-      placeholder: "Ask me anything...",
-      submit_text: "Send",
-      form_class: "chat-form",
-      input_class: "chat-input",
-      submit_class: "chat-submit"
-    ) %>
-  </div>
-</div>
-
-<% content_for :styles do %>
-<style>
-  .chat-container {
-    max-width: 800px;
-    margin: 0 auto;
-    padding: 20px;
-    font-family: system-ui, -apple-system, sans-serif;
-  }
-
-  .chat-header {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: 20px;
-  }
-
-  .new-chat-button {
-    background: #6200ee;
-    color: white;
-    padding: 8px 16px;
-    border-radius: 4px;
-    text-decoration: none;
-  }
-
-  .conversation-container {
-    height: 400px;
-    overflow-y: auto;
-    border: 1px solid #e0e0e0;
-    border-radius: 8px;
-    margin-bottom: 20px;
-    padding: 16px;
-    background: #f8f9fa;
-  }
-
-  .gemini-message {
-    margin-bottom: 16px;
-    padding: 12px;
-    border-radius: 8px;
-  }
-
-  .gemini-user-message {
-    background: #e3f2fd;
-    margin-left: 20px;
-  }
-
-  .gemini-ai-message {
-    background: #f1f3f4;
-    margin-right: 20px;
-  }
-
-  .gemini-message-role {
-    font-weight: bold;
-    margin-bottom: 8px;
-  }
-
-  .gemini-message-timestamp {
-    font-size: 0.8em;
-    color: #666;
-    margin-top: 8px;
-    text-align: right;
-  }
-
-  .chat-form {
-    display: flex;
-    gap: 8px;
-  }
-
-  .chat-input {
-    flex: 1;
-    padding: 12px;
-    border: 1px solid #e0e0e0;
-    border-radius: 4px;
-    font-family: inherit;
-    resize: none;
-    height: 80px;
-  }
-
-  .chat-submit {
-    background: #6200ee;
-    color: white;
-    border: none;
-    padding: 12px 24px;
-    border-radius: 4px;
-    cursor: pointer;
-    align-self: flex-end;
-  }
-</style>
-<% end %>

data/examples/rails_chat/config/routes.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-Rails.application.routes.draw do
-  # Chat routes
-  get "chat", to: "chat#index"
-  post "chat", to: "chat#create"
-  post "chat/reset", to: "chat#reset", as: :reset_chat
-end

data/examples/rails_initializer.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-# config/initializers/geminize.rb
-
-# This is an example of how to configure the Geminize gem in a Rails application.
-# Place this file in your config/initializers directory.
-
-# Configure the Geminize gem with your API key and any other settings
-Geminize.configure do |config|
-  # Required settings
-
-  # Get the API key from environment variables (recommended approach)
-  # config.api_key = ENV["GEMINI_API_KEY"]
-
-  # Or set it directly (not recommended for production)
-  config.api_key = "your-api-key-here"
-
-  # Optional settings with defaults
-
-  # API version to use
-  config.api_version = "v1beta"
-
-  # Default model to use when not specified in requests
-  config.default_model = "gemini-1.5-pro-latest"
-
-  # Request timeout in seconds
-  config.timeout = 30
-
-  # Connection open timeout in seconds
-  config.open_timeout = 10
-
-  # Enable request logging for development/debugging
-  # In production, keep this false unless debugging an issue
-  config.log_requests = Rails.env.development?
-end
-
-# Optionally validate the configuration during app initialization
-# This will raise Geminize::ConfigurationError if the configuration is invalid
-begin
-  Geminize.validate_configuration!
-  Rails.logger.info "Geminize configured successfully"
-rescue Geminize::ConfigurationError => e
-  Rails.logger.error "Geminize configuration error: #{e.message}"
-  # You might want to raise the error in development but not in production
-  raise e if Rails.env.development?
-end

data/lib/geminize/rails/app/controllers/concerns/geminize/controller.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module Geminize
-  # Controller concern for including Gemini functionality in Rails controllers
-  module Controller
-    extend ActiveSupport::Concern
-
-    included do
-      # Helper methods for controllers using Geminize
-      helper_method :current_gemini_conversation if respond_to?(:helper_method)
-    end
-
-    # Current conversation for this controller context
-    # Uses session to maintain conversation state between requests
-    # @return [Geminize::Models::Conversation]
-    def current_gemini_conversation
-      return @current_gemini_conversation if defined?(@current_gemini_conversation)
-
-      if session[:gemini_conversation_id]
-        # Try to load existing conversation
-        begin
-          @current_gemini_conversation = Geminize.load_conversation(session[:gemini_conversation_id])
-        rescue => e
-          Rails.logger.error("Failed to load Gemini conversation: #{e.message}")
-          # Create a new conversation if loading fails
-          create_new_gemini_conversation
-        end
-      else
-        # Create a new conversation if one doesn't exist
-        create_new_gemini_conversation
-      end
-
-      @current_gemini_conversation
-    end
-
-    # Send a message in the current conversation
-    # @param message [String] The message to send
-    # @param model_name [String, nil] Optional model name override
-    # @param params [Hash] Additional parameters for the message
-    # @return [Geminize::Models::ChatResponse] The response
-    def send_gemini_message(message, model_name = nil, params = {})
-      response = Geminize.chat(message, current_gemini_conversation, model_name, params)
-      Geminize.save_conversation(current_gemini_conversation)
-      response
-    end
-
-    # Generate text using Gemini
-    # @param prompt [String] The prompt to send
-    # @param model_name [String, nil] Optional model name override
-    # @param params [Hash] Additional parameters for generation
-    # @return [Geminize::Models::ContentResponse] The response
-    def generate_gemini_text(prompt, model_name = nil, params = {})
-      Geminize.generate_text(prompt, model_name, params)
-    end
-
-    # Generate text with images using Gemini
-    # @param prompt [String] The prompt to send
-    # @param images [Array<Hash>] Array of image data
-    # @param model_name [String, nil] Optional model name override
-    # @param params [Hash] Additional parameters for generation
-    # @return [Geminize::Models::ContentResponse] The response
-    def generate_gemini_multimodal(prompt, images, model_name = nil, params = {})
-      Geminize.generate_text_multimodal(prompt, images, model_name, params)
-    end
-
-    # Generate embeddings for text using Gemini
-    # @param text [String, Array<String>] The text to embed
-    # @param model_name [String, nil] Optional model name override
-    # @param params [Hash] Additional parameters for embedding
-    # @return [Geminize::Models::EmbeddingResponse] The embedding response
-    def generate_gemini_embedding(text, model_name = nil, params = {})
-      Geminize.generate_embedding(text, model_name, params)
-    end
-
-    # Start a new conversation and store its ID in the session
-    # @param title [String, nil] Optional title for the conversation
-    # @param system_instruction [String, nil] Optional system instruction to guide model behavior
-    # @return [Geminize::Models::Conversation] The new conversation
-    def reset_gemini_conversation(title = nil, system_instruction = nil)
-      create_new_gemini_conversation(title, system_instruction)
-    end
-
-    # Set the system instruction for the current conversation
-    # @param system_instruction [String] The system instruction to set
-    # @return [Geminize::Models::Conversation] The updated conversation
-    def set_gemini_system_instruction(system_instruction)
-      current_gemini_conversation.system_instruction = system_instruction
-      Geminize.save_conversation(current_gemini_conversation)
-      current_gemini_conversation
-    end
-
-    private
-
-    # Create a new conversation and store its ID in the session
-    # @param title [String, nil] Optional title for the conversation
-    # @param system_instruction [String, nil] Optional system instruction to guide model behavior
-    # @return [Geminize::Models::Conversation] The new conversation
-    def create_new_gemini_conversation(title = nil, system_instruction = nil)
-      @current_gemini_conversation = Geminize.create_chat(title, system_instruction)
-      session[:gemini_conversation_id] = @current_gemini_conversation.id
-      Geminize.save_conversation(@current_gemini_conversation)
-      @current_gemini_conversation
-    end
-  end
-end

data/lib/geminize/rails/app/helpers/geminize_helper.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module GeminizeHelper
-  # Render the Gemini conversation as HTML
-  # @param conversation [Geminize::Models::Conversation, nil] Conversation to render (defaults to current_gemini_conversation)
-  # @param options [Hash] Optional rendering options
-  # @option options [String] :user_class CSS class for user messages
-  # @option options [String] :ai_class CSS class for AI messages
-  # @option options [Boolean] :include_timestamps Include message timestamps
-  # @return [String] HTML representation of the conversation
-  def render_gemini_conversation(conversation = nil, options = {})
-    conversation ||= current_gemini_conversation if respond_to?(:current_gemini_conversation)
-    return content_tag(:div, "No conversation available", class: "gemini-empty-conversation") unless conversation
-
-    content_tag(:div, class: "gemini-conversation") do
-      conversation.messages.map do |message|
-        render_gemini_message(message, options)
-      end.join.html_safe
-    end
-  end
-
-  # Render a single message from the conversation
-  # @param message [Geminize::Models::Message] The message to render
-  # @param options [Hash] Optional rendering options
-  # @return [String] HTML representation of the message
-  def render_gemini_message(message, options = {})
-    is_user = message.role == "user"
-
-    message_class = if is_user
-      options[:user_class] || "gemini-user-message"
-    else
-      options[:ai_class] || "gemini-ai-message"
-    end
-
-    content_tag(:div, class: "gemini-message #{message_class}") do
-      output = []
-
-      # Add the role label
-      output << content_tag(:div, is_user ? "You" : "AI", class: "gemini-message-role")
-
-      # Add the message content (convert newlines to <br> tags)
-      output << content_tag(:div, simple_format(message.parts.first["text"]), class: "gemini-message-content")
-
-      # Add timestamp if requested
-      if options[:include_timestamps] && message.respond_to?(:timestamp) && message.timestamp
-        timestamp = message.timestamp.is_a?(Time) ? message.timestamp : Time.parse(message.timestamp.to_s)
-        output << content_tag(:div, timestamp.strftime("%Y-%m-%d %H:%M:%S"), class: "gemini-message-timestamp")
-      end
-
-      output.join.html_safe
-    end
-  end
-
-  # Create a chat form that handles submitting messages to Gemini
-  # @param options [Hash] Form options
-  # @option options [String] :submit_text Text for the submit button (default: "Send")
-  # @option options [String] :placeholder Placeholder text (default: "Type your message...")
-  # @option options [String] :form_class CSS class for the form
-  # @option options [String] :input_class CSS class for the input field
-  # @option options [String] :submit_class CSS class for the submit button
-  # @option options [String] :url URL to submit the form to (default: current URL)
-  # @return [String] HTML form
-  def gemini_chat_form(options = {})
-    default_options = {
-      submit_text: "Send",
-      placeholder: "Type your message...",
-      form_class: "gemini-chat-form",
-      input_class: "gemini-chat-input",
-      submit_class: "gemini-chat-submit",
-      url: request.path
-    }
-
-    opts = default_options.merge(options)
-
-    form_tag(opts[:url], method: :post, class: opts[:form_class]) do
-      output = []
-      output << text_area_tag(:message, nil, placeholder: opts[:placeholder], class: opts[:input_class])
-      output << submit_tag(opts[:submit_text], class: opts[:submit_class])
-      output.join.html_safe
-    end
-  end
-
-  # Render Markdown text as HTML
-  # @param text [String] Markdown text to render
-  # @param options [Hash] Options for rendering
-  # @return [String] HTML content
-  def markdown_to_html(text, options = {})
-    return "" if text.blank?
-
-    # Check if the markdown gem is available
-    if defined?(Redcarpet)
-      renderer = Redcarpet::Render::HTML.new(hard_wrap: true, filter_html: false)
-      markdown = Redcarpet::Markdown.new(renderer, options)
-      markdown.render(text).html_safe
-    else
-      # Fall back to simple formatting if Redcarpet is not available
-      simple_format(text)
-    end
-  end
-
-  # Add syntax highlighting to code blocks
-  # @param html [String] HTML content that may contain code blocks
-  # @return [String] HTML with syntax highlighting applied
-  def highlight_code(html)
-    return html unless defined?(Rouge)
-
-    formatter = Rouge::Formatters::HTML.new
-
-    # Find all code blocks and apply syntax highlighting
-    doc = Nokogiri::HTML::DocumentFragment.parse(html)
-    doc.css("pre code").each do |code|
-      lang = code["class"]&.sub("language-", "") || "text"
-      lexer = Rouge::Lexer.find(lang) || Rouge::Lexers::PlainText.new
-
-      # Get the code content and format it
-      code_text = code.text
-      highlighted = formatter.format(lexer.lex(code_text))
-
-      # Replace the original code block with the highlighted version
-      code.parent.replace("<pre class=\"highlight #{lang}\">#{highlighted}</pre>")
-    end
-
-    doc.to_html.html_safe
-  end
-end

data/lib/geminize/rails/controller_additions.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Geminize
-  module Rails
-    # Module for adding Geminize functionality to controllers
-    # Provides methods that make it easy to include Geminize controller concerns.
-    #
-    # This module is automatically included in ActionController::Base
-    # when the gem is used in a Rails application.
-    #
-    # @example Including in a specific controller
-    #   class ChatController < ApplicationController
-    #     geminize_controller
-    #
-    #     def create
-    #       @response = send_gemini_message(params[:message])
-    #       render :show
-    #     end
-    #   end
-    module ControllerAdditions
-      # Add Geminize functionality to a controller
-      # This method includes the Geminize::Controller concern in your controller,
-      # which provides methods for working with the Gemini API.
-      #
-      # @return [void]
-      # @example
-      #   class ApplicationController < ActionController::Base
-      #     include Geminize::Rails::ControllerAdditions
-      #     geminize_controller
-      #   end
-      def geminize_controller
-        include Geminize::Controller
-      end
-    end
-  end
-end
-
-# Add the module to ActionController::Base if it exists
-ActiveSupport.on_load(:action_controller) do
-  include Geminize::Rails::ControllerAdditions
-end

data/lib/geminize/rails/engine.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Geminize
-  module Rails
-    # Rails engine for Geminize
-    # Provides Rails integration for the Gemini API.
-    class Engine < ::Rails::Engine
-      isolate_namespace Geminize
-
-      initializer "geminize.configure" do |app|
-        # Set up configuration if needed
-      end
-
-      initializer "geminize.load_concerns" do
-        ActiveSupport.on_load(:action_controller) do
-          require "geminize/rails/app/controllers/concerns/geminize/controller"
-        end
-
-        ActiveSupport.on_load(:action_view) do
-          require "geminize/rails/app/helpers/geminize_helper"
-        end
-      end
-
-      config.to_prepare do
-        # Load any dependencies that need to be available
-      end
-    end
-  end
-end

data/lib/geminize/rails/helper_additions.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Geminize
-  module Rails
-    # Module for adding Geminize view helpers to Rails applications
-    # Provides methods to simplify the inclusion of Geminize helpers in views.
-    #
-    # This module is automatically included in ActionView::Base
-    # when the gem is used in a Rails application.
-    #
-    # @example Using Geminize helpers in a view
-    #   <%# After including the helpers in ApplicationHelper %>
-    #   <%= render_gemini_conversation %>
-    #   <%= gemini_chat_form %>
-    module HelperAdditions
-      # Add Geminize helpers to views
-      # This method includes the GeminizeHelper module in your view context,
-      # providing helper methods for rendering Gemini conversations, chat forms,
-      # and formatting responses.
-      #
-      # @return [void]
-      # @example
-      #   module ApplicationHelper
-      #     include Geminize::Rails::HelperAdditions
-      #     geminize_helper
-      #   end
-      def geminize_helper
-        include GeminizeHelper
-      end
-    end
-  end
-end
-
-# Add our helpers module to ActionView::Base if it exists
-ActiveSupport.on_load(:action_view) do
-  include Geminize::Rails::HelperAdditions
-end

data/lib/geminize/rails.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "geminize/rails/engine" if defined?(::Rails::Engine)
-require "geminize/railtie" if defined?(::Rails::Railtie)
-require "geminize/rails/controller_additions" if defined?(::ActionController::Base)
-require "geminize/rails/helper_additions" if defined?(::ActionView::Base)
-
-module Geminize
-  # Rails integration module for Geminize
-  # Provides Rails integration for the Google Gemini API.
-  #
-  # The integration includes:
-  # - A Rails engine to load all required components
-  # - Controller concerns with helper methods for Gemini operations
-  # - View helpers for rendering conversations and responses
-  # - Generators for creating configuration files
-  #
-  # @example Setting up in a Rails application
-  #   # In config/initializers/geminize.rb (created by the generator)
-  #   Geminize.configure do |config|
-  #     config.api_key = ENV.fetch("GEMINI_API_KEY")
-  #   end
-  #
-  #   # In app/controllers/chat_controller.rb
-  #   class ChatController < ApplicationController
-  #     geminize_controller
-  #
-  #     def create
-  #       @response = send_gemini_message(params[:message])
-  #       redirect_to chat_path
-  #     end
-  #   end
-  #
-  #   # In app/views/chat/show.html.erb
-  #   <%= render_gemini_conversation %>
-  #   <%= gemini_chat_form %>
-  module Rails
-    # Returns true if running in a Rails environment
-    # Useful for conditionally executing code only in Rails apps.
-    #
-    # @return [Boolean] true if Rails is defined
-    # @example
-    #   if Geminize::Rails.rails?
-    #     # Rails-specific code
-    #   end
-    def self.rails?
-      defined?(::Rails)
-    end
-  end
-end

data/lib/geminize/railtie.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Geminize
-  # Railtie for lightweight Rails integration
-  # Provides basic Rails integration when the full engine is not required.
-  # This is automatically loaded when the gem is used in a Rails application.
-  #
-  # @example Basic usage in a Rails application
-  #   # No additional setup needed - Railtie is loaded automatically
-  #   # In your controller:
-  #   class ExamplesController < ApplicationController
-  #     def example
-  #       @response = Geminize.generate_text("What is Ruby on Rails?").text
-  #     end
-  #   end
-  class Railtie < ::Rails::Railtie
-    # Configure Geminize when used in a Rails application
-    # @return [void]
-    initializer "geminize.configure" do |app|
-      # Set up configuration for Geminize when used in a Rails app
-      Geminize.configure do |config|
-        # Set conversations path to Rails tmp directory by default
-        config.conversations_path = Rails.root.join("tmp", "conversations") if config.conversations_path.nil?
-      end
-    end
-
-    # Set up any rake tasks if needed
-    # @return [void]
-    rake_tasks do
-      # Define rake tasks here if needed
-    end
-  end
-end

data/lib/generators/geminize/install_generator.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators/base"
-
-module Geminize
-  module Generators
-    # Generator for installing Geminize Rails integration
-    # This generator creates an initializer with default configuration
-    class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path("templates", __dir__)
-      desc "Creates a Geminize initializer for Rails."
-
-      def create_initializer_file
-        template "initializer.rb", "config/initializers/geminize.rb"
-      end
-
-      def show_readme
-        readme "README" if behavior == :invoke
-      end
-    end
-  end
-end

data/lib/generators/geminize/templates/README

@@ -1,31 +0,0 @@
-===============================================================================
-
-Geminize has been successfully installed!
-
-A configuration initializer has been created at:
-  config/initializers/geminize.rb
-
-You need to edit the initializer and add your Google Gemini API key.
-You can get an API key from https://ai.google.dev/
-
-===============================================================================
-
-Usage Examples:
-
-# Basic text generation
-text = Geminize.generate_text("What is Ruby on Rails?").text
-puts text
-
-# Create a chat session
-chat = Geminize.create_chat("My Support Chat")
-response = Geminize.chat("How can I create a Ruby gem?", chat)
-puts response.text
-
-# Follow-up question (keeps conversation context)
-response = Geminize.chat("What about adding a Rails engine to my gem?", chat)
-puts response.text
-
-# For more examples, see the documentation at:
-# https://github.com/nhlongnguyen/geminize
-
-===============================================================================

data/lib/generators/geminize/templates/initializer.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-# Geminize Configuration
-#
-# This file contains the configuration for the Geminize gem.
-# It is used to set up the Google Gemini API integration.
-
-Geminize.configure do |config|
-  # Your Google Gemini API key
-  # You can get one from https://ai.google.dev/
-  # Can also be set via GEMINI_API_KEY environment variable
-  # config.api_key = ENV.fetch("GEMINI_API_KEY", nil)
-
-  # The API version to use (default: v1beta)
-  # config.api_version = "v1beta"
-
-  # The default model to use (default: gemini-2.0-flash)
-  # config.default_model = "gemini-2.0-flash"
-
-  # The base URL for the Gemini API (default: https://generativelanguage.googleapis.com)
-  # config.api_base_url = "https://generativelanguage.googleapis.com"
-
-  # Logging level for Geminize (default: :info)
-  # Valid values: :debug, :info, :warn, :error, :fatal
-  # config.log_level = Rails.env.production? ? :info : :debug
-
-  # Where to store conversation data (default: Rails.root.join("tmp", "conversations"))
-  # Only applicable when using FileConversationRepository
-  # config.conversations_path = Rails.root.join("tmp", "conversations")
-
-  # Default parameters for text generation
-  # config.generation_defaults = {
-  #   temperature: 0.7,
-  #   max_tokens: 500,
-  #   top_p: 0.95,
-  #   top_k: 40
-  # }
-end