sandals 0.1.0

data/lib/sandals/binding_resolver.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sandals
+  class BindingResolver
+    UNSET = Object.new.freeze
+    Resolution = Data.define(:value, :error, :action)
+
+    def self.resolve(**options)
+      new(**options).resolve
+    end
+
+    def initialize(model:, bind:, value:, error:, action:, default:)
+      @model = model
+      @bind = bind
+      @value = value
+      @error = error
+      @action = action
+      @default = default
+    end
+
+    def resolve
+      return explicit_resolution unless binding_requested?
+
+      validate_binding
+
+      attribute = @bind.to_sym
+      writer = :"#{attribute}="
+      validate_accessors(attribute, writer)
+
+      Resolution.new(
+        @model.public_send(attribute),
+        resolved_error(attribute),
+        ->(new_value) { @model.public_send(writer, new_value) }
+      )
+    end
+
+    private
+
+    def binding_requested?
+      !@model.equal?(UNSET) || !@bind.equal?(UNSET)
+    end
+
+    def explicit_resolution
+      value = @value.equal?(UNSET) ? @default : @value
+      error = @error.equal?(UNSET) ? nil : @error
+      Resolution.new(value, error, @action)
+    end
+
+    def validate_binding
+      raise ArgumentError, "bind requires model" if @model.equal?(UNSET)
+      raise ArgumentError, "model requires bind" if @bind.equal?(UNSET)
+      raise ArgumentError, "bind must be a method name" unless @bind.respond_to?(:to_sym)
+      raise ArgumentError, "bind cannot be combined with value" unless @value.equal?(UNSET)
+      raise ArgumentError, "bind cannot be combined with an action" if @action
+    end
+
+    def validate_accessors(attribute, writer)
+      return if @model.respond_to?(attribute) && @model.respond_to?(writer)
+
+      raise ArgumentError,
+        "#{@model.class} must respond to #{attribute} and #{writer}"
+    end
+
+    def resolved_error(attribute)
+      return @error unless @error.equal?(UNSET)
+      return unless @model.respond_to?(:errors)
+
+      errors = @model.errors
+      return unless errors.respond_to?(:[])
+
+      error = errors[attribute]
+      return if error.respond_to?(:empty?) && error.empty?
+
+      error
+    end
+  end
+end

data/lib/sandals/cli.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "../sandals"
+
+module Sandals
+  class CLI
+    def self.start(arguments)
+      new(arguments).run
+    end
+
+    def initialize(arguments)
+      @arguments = arguments.dup
+    end
+
+    def run
+      command = @arguments.shift
+      return usage unless command == "run"
+
+      run_app
+    rescue Interrupt
+      0
+    rescue StandardError => error
+      warn "sandals: #{error.message}"
+      1
+    end
+
+    private
+
+    def run_app
+      options = { open: true, port: 0 }
+      parser = OptionParser.new do |opts|
+        opts.on("--no-open") { options[:open] = false }
+        opts.on("-pPORT", "--port=PORT", Integer) { |port| options[:port] = port }
+      end
+      parser.parse!(@arguments)
+
+      path = resolve_app(@arguments.shift || "app")
+      application = Sandals.load(path)
+      server = Server.new(application, port: options[:port], reload_path: path)
+
+      trap("INT") { server.stop }
+      puts "Sandals está corriendo #{path}"
+      puts server.url
+      open_browser(server.url) if options[:open]
+      server.start
+      0
+    end
+
+    def resolve_app(name)
+      candidates = [name]
+      candidates << "#{name}.rb" unless name.end_with?(".rb")
+      path = candidates.find { |candidate| File.file?(candidate) }
+      return path if path
+
+      raise ArgumentError, "could not find #{candidates.join(' or ')}"
+    end
+
+    def open_browser(url)
+      command =
+        case RUBY_PLATFORM
+        when /darwin/ then ["open", url]
+        when /mingw|mswin/ then ["cmd", "/c", "start", url]
+        else ["xdg-open", url]
+        end
+
+      system(*command, out: File::NULL, err: File::NULL)
+    end
+
+    def usage
+      warn "Usage: sandals run APP [--no-open] [--port PORT]"
+      1
+    end
+  end
+end

data/lib/sandals/code_reloader.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Sandals
+  class CodeReloader
+    ANSI_ESCAPE = /\e\[[0-9;]*m/
+
+    Result = Data.define(:version, :application, :error, :changed)
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = File.expand_path(path)
+      @signature = signature
+      @version = 1
+      @error = nil
+      @mutex = Mutex.new
+    end
+
+    def check
+      @mutex.synchronize do
+        current_signature = signature
+        return result unless current_signature != @signature
+
+        @signature = current_signature
+        application = Sandals.load(path)
+        @version += 1
+        @error = nil
+        Result.new(@version, application, nil, true)
+      rescue SyntaxError, LoadError, StandardError => error
+        @error = error_details(error)
+        result(changed: true)
+      end
+    end
+
+    private
+
+    def result(changed: false)
+      Result.new(@version, nil, @error, changed)
+    end
+
+    def signature
+      stat = File.stat(path)
+      [stat.mtime.to_f, stat.size]
+    rescue Errno::ENOENT
+      [:missing]
+    end
+
+    def error_details(error)
+      {
+        class: error.class.to_s,
+        message: clean_message(error),
+        location: error_location(error)
+      }
+    end
+
+    def error_location(error)
+      syntax_location =
+        clean_message(error).lines.first&.match(/\A(.+?):(\d+):/) if
+          error.is_a?(SyntaxError)
+      if syntax_location
+        source_path = syntax_location[1].delete_prefix("#{Dir.pwd}/")
+        return "#{source_path}:#{syntax_location[2]}"
+      end
+
+      locations = error.backtrace_locations || []
+      location = locations.find do |candidate|
+        !candidate.absolute_path.to_s.include?("/lib/sandals/")
+      end || locations.first
+      return path unless location
+
+      source_path = location.absolute_path || location.path
+      source_path = source_path.delete_prefix("#{Dir.pwd}/")
+      "#{source_path}:#{location.lineno}"
+    end
+
+    def clean_message(error)
+      error.message.gsub(ANSI_ESCAPE, "")
+    end
+  end
+end

data/lib/sandals/event_dispatcher.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sandals
+  class EventDispatcher
+    def initialize(controls)
+      @controls = controls
+    end
+
+    def dispatch(events)
+      events.each { |event| dispatch_event(event) }
+    end
+
+    private
+
+    def dispatch_event(event)
+      target = event.fetch("target")
+      name = event.fetch("event")
+      control = @controls.find { |candidate| candidate.id == target }
+      raise ArgumentError, "unknown control: #{target}" unless control
+
+      case [control, name]
+      in [TextField | NumberField | TextArea | Checkbox | Select, "change"]
+        control.change(event["value"])
+      in [FileField, "change"]
+        control.change(event.fetch("value"))
+      in [Submit, "submit"]
+        control.submit
+      in [Button, "click"]
+        control.activate
+      else
+        raise ArgumentError, "#{control.class} does not respond to #{name}"
+      end
+    end
+  end
+end